def createEllipsoid(radius, center):
"""
Create a parametric ellipsoid with the given values.
:@type radius: Vec3d
:@param radius: The 3D radius of the ellipsoid
:@type center: Vec3D
:@param center: The center of the ellipsoid
:@rtype: vtk.vtkActor
:@return: An actor mapped from a parametric ellipsoid source
"""
tol = 0
# set up the source
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(radius.x+tol)
ellipsoid.SetYRadius(radius.y+tol)
ellipsoid.SetZRadius(radius.z+tol)
ellipsoidSource = vtk.vtkParametricFunctionSource()
ellipsoidSource.SetParametricFunction(ellipsoid)
# mapper and actor
ellipsoidMapper = vtk.vtkPolyDataMapper()
ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort())
ellipsoidActor = vtk.vtkActor()
ellipsoidActor.SetMapper(ellipsoidMapper)
ellipsoidActor.SetPosition(center.x, center.y, center.z)
return ellipsoidActor
def Torus(pos=(0, 0, 0), r=1, thickness=0.1, axis=(0, 0, 1), c="khaki", alpha=1, res=30):
"""
Build a torus of specified outer radius `r` internal radius `thickness`, centered at `pos`.
.. hint:: |gas| |gas.py|_
"""
rs = vtk.vtkParametricTorus()
rs.SetRingRadius(r)
rs.SetCrossSectionRadius(thickness)
pfs = vtk.vtkParametricFunctionSource()
pfs.SetParametricFunction(rs)
pfs.SetUResolution(res * 3)
pfs.SetVResolution(res)
pfs.Update()
nax = np.linalg.norm(axis)
if nax:
axis = np.array(axis) / nax
theta = np.arccos(axis[2])
phi = np.arctan2(axis[1], axis[0])
t = vtk.vtkTransform()
t.PostMultiply()
t.RotateY(np.rad2deg(theta))
t.RotateZ(np.rad2deg(phi))
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInputData(pfs.GetOutput())
tf.SetTransform(t)
tf.Update()
pd = tf.GetOutput()
actor = Actor(pd, c, alpha)
actor.GetProperty().SetInterpolationToPhong()
actor.SetPosition(pos)
settings.collectable_actors.append(actor)
return actor
def addTorus(center, radii, rotation, rotation_axis='Y',resolution=50):
torus = vtk.vtkParametricTorus()
torus.SetRingRadius(radii[0])
torus.SetCrossSectionRadius(radii[1])
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetUResolution(resolution)
torusSource.SetVResolution(resolution)
torusSource.Update()
transform = vtk.vtkTransform()
if(rotation_axis=='X'):
transform.RotateX(rotation)
elif(rotation_axis=='Y'):
transform.RotateY(rotation)
else:
transform.RotateZ(rotation)
transform.Translate(center)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputConnection(torusSource.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkParametricFunctionSource(), 'Processing.',
(), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def _create_geometry(self):
self._spline_source = vtk.vtkParametricFunctionSource()
s = vtk.vtkParametricSpline()
if False:
# these are quite ugly...
# later: factor this out into method, so that we can
# experiment live with different spline params. For now
# the vtkCardinal spline that is used is muuuch prettier.
ksplines = []
for i in range(3):
ksplines.append(vtk.vtkKochanekSpline())
ksplines[-1].SetDefaultTension(0)
ksplines[-1].SetDefaultContinuity(0)
ksplines[-1].SetDefaultBias(0)
s.SetXSpline(ksplines[0])
s.SetYSpline(ksplines[1])
s.SetZSpline(ksplines[2])
pts = vtk.vtkPoints()
s.SetPoints(pts)
self._spline_source.SetParametricFunction(s)
m = vtk.vtkPolyDataMapper()
m.SetInputConnection(self._spline_source.GetOutputPort())
a = vtk.vtkActor()
a.SetMapper(m)
a.GetProperty().SetColor(self.line_colour)
a.GetProperty().SetLineWidth(self._normal_width)
self.props = [a]
def GetRandomHills():
uResolution = 51
vResolution = 51
surface = vtk.vtkParametricRandomHills()
surface.SetRandomSeed(1)
surface.SetNumberOfHills(30)
# If you want a plane
# surface.SetHillAmplitude(0)
source = vtk.vtkParametricFunctionSource()
source.SetUResolution(uResolution)
source.SetVResolution(vResolution)
source.SetParametricFunction(surface)
source.Update()
# Build the tcoords
pd = UVTcoords(uResolution, vResolution, source.GetOutput())
# Now the tangents
tangents = vtk.vtkPolyDataTangents()
tangents.SetInputData(pd)
tangents.Update()
transform = vtk.vtkTransform()
transform.RotateZ(180.0)
transform.RotateX(90.0)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(tangents.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def MakeParametricHills():
"""
Make a parametric hills surface as the source.
:return: vtkPolyData with normal and scalar data.
"""
fn = vtk.vtkParametricRandomHills()
fn.AllowRandomGenerationOn()
fn.SetRandomSeed(1)
fn.SetNumberOfHills(30)
# Make the normals face out of the surface.
# Not needed with VTK 8.0 or later.
# if fn.GetClassName() == 'vtkParametricRandomHills':
# fn.ClockwiseOrderingOff()
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(fn)
source.SetUResolution(50)
source.SetVResolution(50)
source.SetScalarModeToZ()
source.Update()
# Name the arrays (not needed in VTK 6.2+ for vtkParametricFunctionSource)
source.GetOutput().GetPointData().GetNormals().SetName('Normals')
# We have calculated the elevation, just rename the scalars.
source.GetOutput().GetPointData().GetScalars().SetName('Elevation')
return CalculateCurvatures(source.GetOutput())
def CreateTorus(point1, point2, axe): """ Creates a torus that has point1 as center point2 defines a point on the torus. """ direction = map(lambda x, y: x - y, point2, point1) length = math.sqrt(sum(map(lambda x: x ** 2, direction))) torus = vtkParametricTorus() torus.SetRingRadius(length / 1.5) torus.SetCrossSectionRadius(length / 30.0) torusSource = vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusSource.Update() transform = vtkTransform() if axe == 0: transform.RotateY(90) elif axe == 1: transform.RotateX(90) transformFilter = vtkTransformFilter() transformFilter.SetInputConnection(torusSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() torusMapper = vtkPolyDataMapper() torusMapper.SetInputConnection(transformFilter.GetOutputPort()) torusActor = vtkActor() torusActor.SetMapper(torusMapper) return torusActor, transformFilter.GetOutput()
def GetTorus():
uResolution = 51
vResolution = 51
surface = vtk.vtkParametricTorus()
source = vtk.vtkParametricFunctionSource()
source.SetUResolution(uResolution)
source.SetVResolution(vResolution)
source.SetParametricFunction(surface)
source.Update()
# Build the tcoords
pd = UVTcoords(uResolution, vResolution, source.GetOutput())
# Now the tangents
tangents = vtk.vtkPolyDataTangents()
tangents.SetInputData(pd)
tangents.Update()
transform = vtk.vtkTransform()
transform.RotateX(90.0)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(tangents.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
return transformFilter.GetOutput()
def _generate_ellipsoid(self):
if self.geometry != "ellipsoid":
return vtkActor()
else:
_actor = vtkActor()
self._other_vtk_settings()
_param_ellipsoid = vtkParametricEllipsoid()
_param_ellipsoid.SetXRadius(self.dim[0] / 2)
_param_ellipsoid.SetYRadius(self.dim[1] / 2)
_param_ellipsoid.SetZRadius(self.dim[2] / 2)
_source = vtkParametricFunctionSource()
_source.SetParametricFunction(_param_ellipsoid)
if 'center' in self.kwargs:
_source.SetCenter(self.kwargs['center'])
elif 'resolution' in self.kwargs:
_source.SetUResolution(self.kwargs['resolution'])
_source.SetVResolution(self.kwargs['resolution'])
self._mapper.SetInputConnection(_source.GetOutputPort())
_actor.SetMapper(self._mapper)
return _actor
def __init__(self,
r1=1,
r2=0.25,
center=(0, 0, 0),
rotXYZ=(0, 0, 0),
color=(1, 0, 0)):
self.parfun = vtk.vtkParametricSuperToroid()
self.parfun.SetRingRadius(r1)
self.parfun.SetCrossSectionRadius(r2)
self.parfun.SetN1(1)
self.parfun.SetN2(1)
self.src = vtk.vtkParametricFunctionSource()
self.src.SetParametricFunction(self.parfun)
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2])
transform.RotateX(rotXYZ[0])
transform.RotateY(rotXYZ[1])
transform.RotateZ(rotXYZ[2])
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(self.src.GetOutputPort())
transformFilter.Update()
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(transformFilter.GetOutputPort())
self.SetMapper(self.mapper)
self.SetColor(color)
def CreateTorus(point1, point2, axe):
"""
Creates a torus that has point1 as center point2 defines
a point on the torus.
"""
direction = map(lambda x, y: x - y, point2, point1)
length = math.sqrt(sum(map(lambda x: x**2, direction)))
torus = vtkParametricTorus()
torus.SetRingRadius(length / 1.5)
torus.SetCrossSectionRadius(length / 30.0)
torusSource = vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusSource.Update()
transform = vtkTransform()
if axe == 0:
transform.RotateY(90)
elif axe == 1:
transform.RotateX(90)
transformFilter = vtkTransformFilter()
transformFilter.SetInputConnection(torusSource.GetOutputPort())
transformFilter.SetTransform(transform)
transformFilter.Update()
torusMapper = vtkPolyDataMapper()
torusMapper.SetInputConnection(transformFilter.GetOutputPort())
torusActor = vtkActor()
torusActor.SetMapper(torusMapper)
return torusActor, transformFilter.GetOutput()
def _create_geometry(self):
self._spline_source = vtk.vtkParametricFunctionSource()
s = vtk.vtkParametricSpline()
if False:
# these are quite ugly...
# later: factor this out into method, so that we can
# experiment live with different spline params. For now
# the vtkCardinal spline that is used is muuuch prettier.
ksplines = []
for i in range(3):
ksplines.append(vtk.vtkKochanekSpline())
ksplines[-1].SetDefaultTension(0)
ksplines[-1].SetDefaultContinuity(0)
ksplines[-1].SetDefaultBias(0)
s.SetXSpline(ksplines[0])
s.SetYSpline(ksplines[1])
s.SetZSpline(ksplines[2])
pts = vtk.vtkPoints()
s.SetPoints(pts)
self._spline_source.SetParametricFunction(s)
m = vtk.vtkPolyDataMapper()
m.SetInput(self._spline_source.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
a.GetProperty().SetColor(self.line_colour)
a.GetProperty().SetLineWidth(self._normal_width)
self.props = [a]
def surface_from_para(parametric_function, u_res=100, v_res=100,
w_res=100):
"""Construct a mesh from a parametric function.
Parameters
----------
parametric_function : vtk.vtkParametricFunction
Parametric function to generate mesh from.
u_res : int, optional
Resolution in the u direction.
v_res : int, optional
Resolution in the v direction.
w_res : int, optional
Resolution in the w direction.
"""
# convert to a mesh
para_source = vtk.vtkParametricFunctionSource()
para_source.SetParametricFunction(parametric_function)
para_source.SetUResolution(u_res)
para_source.SetVResolution(v_res)
para_source.SetWResolution(w_res)
para_source.Update()
return pyvista.wrap(para_source.GetOutput())
def CreateEllipsoid(center, axis, xRadius, yRadius, zRadius):
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(xRadius)
ellipsoid.SetYRadius(yRadius)
ellipsoid.SetZRadius(zRadius)
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(ellipsoid)
source.SetUResolution(15)
source.SetVResolution(15)
source.SetWResolution(15)
source.Update()
polydata = source.GetOutput()
#polydata.Update()
#Perform rotation to get the rigth axis
oldAxis = (0, 1, 0)
polydata = MeshRotate(polydata, oldAxis, axis)
#Perform translation to get the rigth center
translationVector = center
polydata = MeshTranslate(polydata, translationVector)
return polydata
def Get_Interpolated_CtrlPoints(self, num_of_points):
'''
Input:
num_of_points: Number of contorl points after interpolation
Output: numpy array (3*n), position of interpolated contorl points
Description: Get a specific number of control points through interpolation
'''
Points = vtk.vtkPoints()
for i in range(self._ctrl_points.shape[0]):
Points.InsertPoint(i, self._ctrl_points[i][0],
self._ctrl_points[i][1],
self._ctrl_points[i][2])
Points.Modified()
ParametricSpline = vtk.vtkParametricSpline()
ParametricSpline.SetPoints(Points)
if self._is_closer:
ParametricSpline.ClosedOn()
else:
ParametricSpline.ClosedOff()
ParametricSpline.Modified()
ParametricFunctionSource = vtk.vtkParametricFunctionSource()
ParametricFunctionSource.SetParametricFunction(ParametricSpline)
ParametricFunctionSource.SetUResolution(num_of_points)
ParametricFunctionSource.Update()
points = np.array(
ParametricFunctionSource.GetOutput().GetPoints().GetData())
return points
def ParametricTorusSource():
torus = vtk.vtkParametricTorus()
torus.JoinUOff()
torus.JoinVOff()
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToZ()
return torusSource
def from_mobius(cls, mat=None):
mobius = vtk.vtkParametricMobius()
mobius.SetRadius(2)
mobius.SetMinimumV(-0.5)
mobius.SetMaximumV(0.5)
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(mobius)
return cls('mobius', source, mat)
def BoySource():
boy = vtk.vtkParametricBoy()
boy.JoinUOff()
# boy.JoinVOff()
boySource = vtk.vtkParametricFunctionSource()
boySource.SetParametricFunction(boy)
boySource.SetScalarModeToZ()
return boySource
def MobiusSource():
mobius = vtk.vtkParametricMobius()
mobius.SetRadius(2)
mobius.SetMinimumV(-0.5)
mobius.SetMaximumV(0.5)
mobius.JoinUOff()
mobiusSource = vtk.vtkParametricFunctionSource()
mobiusSource.SetParametricFunction(mobius)
mobiusSource.SetScalarModeToX()
return mobiusSource
def ParametricRandomHills():
randomHills = vtk.vtkParametricRandomHills()
# randomHills.AllowRandomGenerationOff()
randomHills.SetRandomSeed(1)
randomHills.SetNumberOfHills(30)
randomHillsSource = vtk.vtkParametricFunctionSource()
randomHillsSource.SetParametricFunction(randomHills)
randomHillsSource.SetScalarModeToZ()
randomHillsSource.SetUResolution(10)
randomHillsSource.SetVResolution(10)
return randomHillsSource
def EllipsoidSource():
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(0.5)
ellipsoid.SetYRadius(1.0)
ellipsoid.SetZRadius(2.0)
ellipsoid.JoinUOff()
# ellipsoid.JoinVOff()
ellipsoidSource = vtk.vtkParametricFunctionSource()
ellipsoidSource.SetParametricFunction(ellipsoid)
ellipsoidSource.SetScalarModeToZ()
return ellipsoidSource
def set_centerline(self, resolution):
xmin,xmax, ymin,ymax, zmin,zmax = self.obj.GetBounds()
center = self.obj.GetCenter() # colon center
step = [zmin, (zmin+center[2])/2, center[2], (zmax+center[2])/2, zmax]
posx, posy, posx2, posy2 = [], [], [], []
negx, negy, negx2, negy2 = [], [], [], []
N = self.obj.GetNumberOfPoints()
for i in range(N):
p = [0] * 3
self.obj.GetPoint(i, p)
if p[2]>step[3]:
posx.append(p[0])
posy.append(p[1])
elif p[2]>step[2]:
posx2.append(p[0])
posy2.append(p[1])
elif p[2]>step[1]:
negx2.append(p[0])
negy2.append(p[1])
else:
negx.append(p[0])
negy.append(p[1])
# key points
c_posx, c_posy = np.average(np.array(posx)), np.average(np.array(posy))
c_posx2, c_posy2 = np.average(np.array(posx2)), np.average(np.array(posy2))
c_negx, c_negy = np.average(np.array(negx)), np.average(np.array(negy))
c_negx2, c_negy2 = np.average(np.array(negx2)), np.average(np.array(negy2))
pts = vtk.vtkPoints()
# pts.InsertNextPoint([c_posx, c_posy, zmax])
pts.InsertNextPoint([np.average(np.array(posx)), np.average(np.array(posy)), step[4]])
pts.InsertNextPoint([np.average(np.array(posx2)), np.average(np.array(posy2)), step[3]])
#pts.InsertNextPoint([center[0], center[1], zmin])
#pts.InsertNextPoint([(c_negx2+c_posx2)/2, (c_negy2+c_posy2)/2, 0])
pts.InsertNextPoint([np.average(np.array(negx2+posx2)), np.average(np.array(negy2+posy2)), step[2]])
pts.InsertNextPoint([np.average(np.array(negx2)), np.average(np.array(negy2)), step[1]])
pts.InsertNextPoint([np.average(np.array(negx)), np.average(np.array(negy)), step[0]])
# pts.InsertNextPoint([c_negx, c_negy, zmin])
#pts.InsertNextPoint([center[0], center[1], zmax])
# spline from keypoints
spline = vtk.vtkParametricSpline()
spline.SetPoints(pts)
function = vtk.vtkParametricFunctionSource()
function.SetParametricFunction(spline)
function.Update()
function.SetUResolution(resolution)
function.Update()
self.centerline = function.GetOutput() # centerline
self.cl_scale = (zmax-zmin)/resolution
# centerline direction, [0, 0, 1]
self.direction = [0, 0, zmax-zmin]
self.math.Normalize(self.direction)
def CreateRandomHills():
randomHills = vtk.vtkParametricRandomHills()
randomHills.AllowRandomGenerationOff()
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(randomHills)
source.Update()
polydata = source.GetOutput()
#polydata.Update()
return polydata
def main():
colors = vtk.vtkNamedColors()
colors.SetColor("BkgColor", [26, 51, 102, 255])
# Uncomment one of the following.
# parametricObject = vtk.vtkParametricBoy()
# parametricObject = vtk.vtkParametricConicSpiral()
# parametricObject = vtk.vtkParametricCrossCap()
# parametricObject = vtk.vtkParametricDini()
# parametricObject = vtk.vtkParametricEllipsoid()
# parametricObject = vtk.vtkParametricEnneper()
parametricObject = vtk.vtkParametricFigure8Klein()
# parametricObject = vtk.vtkParametricKlein()
# parametricObject = vtk.vtkParametricMobius()
# parametricObject = vtk.vtkParametricRandomHills()
# parametricObject = vtk.vtkParametricRoman()
# parametricObject = vtk.vtkParametricSpline()
# parametricObject = vtk.vtkParametricSuperEllipsoid()
# parametricObject = vtk.vtkParametricSuperToroid()
# parametricObject = vtk.vtkParametricTorus()
parametricFunctionSource = vtk.vtkParametricFunctionSource()
parametricFunctionSource.SetParametricFunction(parametricObject)
parametricFunctionSource.Update()
# Visualize
backProperty = vtk.vtkProperty()
backProperty.SetColor(colors.GetColor3d("Tomato"))
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(parametricFunctionSource.GetOutputPort())
# Create an actor for the contours
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d("Banana"))
actor.GetProperty().SetSpecular(.5)
actor.GetProperty().SetSpecularPower(20)
actor.SetBackfaceProperty(backProperty)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetWindowName("Parametric Objects")
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("BkgColor"))
renderWindow.Render()
interactor.Start()
def get_spline_actor(surface_data, chassis_cg_path, surface_bounds):
# Iterate over chassis CG points and create a spline which marks the driving path.
# Return the spline as a vtkActor for being added later to the renderer.
# Update the pipeline so that vtkCellLocator finds cells
surface_data.Update()
# Define a cellLocator to be able to compute intersections between lines
# and the surface
locator = vtkCellLocator()
locator.SetDataSet(surface_data.GetOutput())
locator.BuildLocator()
tolerance = 0.01 # Set intersection searching tolerance
# Make a list of points. Each point is the intersection of a vertical line
# defined by p1 and p2 and the surface.
points = vtkPoints()
for chassis_cg in chassis_cg_path:
p1 = [chassis_cg[0], chassis_cg[1], surface_bounds[4]]
p2 = [chassis_cg[0], chassis_cg[1], surface_bounds[5]]
t = mutable(0)
pos = [0.0, 0.0, 0.0]
pcoords = [0.0, 0.0, 0.0]
subId = mutable(0)
locator.IntersectWithLine(p1, p2, tolerance, t, pos, pcoords, subId)
# Add a slight offset in z
pos[2] += 0.05
# Add the x, y, z position of the intersection
points.InsertNextPoint(pos)
# Create a spline and add the pointsoi
spline = vtkParametricSpline()
spline.SetPoints(points)
spline_function = vtkParametricFunctionSource()
spline_function.SetUResolution(len(chassis_cg_path))
spline_function.SetParametricFunction(spline)
# Map the spline
spline_mapper = vtkPolyDataMapper()
spline_mapper.SetInputConnection(spline_function.GetOutputPort())
# Define the line actor
spline_actor = vtkActor()
spline_actor.SetMapper(spline_mapper)
spline_actor.GetProperty().SetColor([0, 0.7, 0])
spline_actor.GetProperty().SetLineWidth(10)
return spline_actor
def _createTube(self):
logging.debug("In MultiSliceContour::createTube()")
points = vtk.vtkPoints()
for point in self._originalPoints:
points.InsertNextPoint(point)
self._parametricSpline = vtk.vtkParametricSpline()
self._parametricSpline.SetPoints(points)
self._parametricFuntionSource = vtk.vtkParametricFunctionSource()
self._parametricFuntionSource.SetParametricFunction(self._parametricSpline)
self._parametricFuntionSource.SetUResolution(100)
self._tubeFilter = vtk.vtkTubeFilter()
self._tubeFilter.SetNumberOfSides(10)
self._tubeFilter.SetRadius(self._radius)
self._tubeFilter.SetInputConnection(self._parametricFuntionSource.GetOutputPort())
self._tubeActor = []
self._cubes = []
i = 0
for cutter in self._cutters:
cutter.SetInputConnection(self._tubeFilter.GetOutputPort())
cutter.Update()
cube = vtk.vtkBox()
#TODO change imagebounds to planesourceRange
cube.SetBounds(self._scene.slice[i].getBounds())
clip = vtk.vtkClipPolyData()
clip.SetClipFunction(cube)
clip.SetInputConnection(cutter.GetOutputPort())
clip.InsideOutOn()
clip.Update()
self._cubes.append(cube)
tubeMapper=vtk.vtkPolyDataMapper()
tubeMapper.ScalarVisibilityOff()
tubeMapper.SetInputConnection(clip.GetOutputPort())
tubeMapper.GlobalImmediateModeRenderingOn()
tubeActor = vtk.vtkActor()
tubeActor.SetMapper(tubeMapper)
tubeActor.GetProperty().LightingOff()
tubeActor.GetProperty().SetColor(self.lineColor)
tubeActor.SetUserTransform(self._scene.slice[i].resliceTransform.GetInverse())
self._tubeActor.append(tubeActor)
self._scene.renderer.AddActor(tubeActor)
i = i+1
def ParametricObjects(self):
colors = vtk.vtkNamedColors()
# Select one of the following functions.
# parametricObject = vtk.vtkParametricBoy()
# parametricObject = vtk.vtkParametricConicSpiral()
# parametricObject = vtk.vtkParametricCrossCap()
# parametricObject = vtk.vtkParametricDini()
# parametricObject = vtk.vtkParametricEllipsoid()
# parametricObject = vtk.vtkParametricEnneper()
# parametricObject = vtk.vtkParametricFigure8Klein()
# parametricObject = vtk.vtkParametricKlein()
# parametricObject = vtk.vtkParametricMobius()
# parametricObject = vtk.vtkParametricRandomHills()
# parametricObject = vtk.vtkParametricRoman()
# parametricObject = vtk.vtkParametricSpline()
# parametricObject = vtk.vtkParametricSuperEllipsoid()
# parametricObject = vtk.vtkParametricSuperToroid()
parametricObject = vtk.vtkParametricTorus()
parametricSource = vtk.vtkParametricFunctionSource()
parametricSource.SetParametricFunction(parametricObject)
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(parametricSource.GetOutputPort())
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Burlywood"))
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and Interactor
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
renWin.AddRenderer(ren)
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(actor)
ren.SetBackground(colors.GetColor3d("Beige"))
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def ring(pos=[0, 0, 0],
r=1,
thickness=0.1,
axis=[0, 0, 1],
c='khaki',
alpha=1,
wire=False,
legend=None,
texture=None,
res=30):
'''
Build a torus of specified outer radius r internal radius thickness, centered at pos.
[**Example**](https://github.com/marcomusy/vtkplotter/blob/master/examples/advanced/gas.py)
'''
rs = vtk.vtkParametricTorus()
rs.SetRingRadius(r)
rs.SetCrossSectionRadius(thickness)
pfs = vtk.vtkParametricFunctionSource()
pfs.SetParametricFunction(rs)
pfs.SetUResolution(res * 3)
pfs.SetVResolution(res)
pfs.Update()
nax = np.linalg.norm(axis)
if nax:
axis = np.array(axis) / nax
theta = np.arccos(axis[2])
phi = np.arctan2(axis[1], axis[0])
t = vtk.vtkTransform()
t.PostMultiply()
t.RotateY(theta * 57.3)
t.RotateZ(phi * 57.3)
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInputData(pfs.GetOutput())
tf.SetTransform(t)
tf.Update()
pd = tf.GetOutput()
actor = Actor(pd,
c=c,
alpha=alpha,
wire=wire,
legend=legend,
texture=texture)
actor.GetProperty().SetInterpolationToPhong()
actor.SetPosition(pos)
return actor
def Torus(radius_ring, radius_cross_section):
ellipsoid = vtk.vtkParametricTorus()
ellipsoid.SetRingRadius(radius_ring)
ellipsoid.SetCrossSectionRadius(radius_cross_section)
parametricSource = vtk.vtkParametricFunctionSource()
parametricSource.SetParametricFunction(ellipsoid)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(parametricSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def torus(pos=[0, 0, 0],
r=1,
thickness=0.1,
axis=[0, 0, 1],
c='khaki',
alpha=1,
wire=False,
legend=None,
texture=None,
res=30):
'''
Build a torus of specified outer radius `r` internal radius `thickness`, centered at `pos`.
.. hint:: Example: `gas.py <https://github.com/marcomusy/vtkplotter/blob/master/examples/advanced/gas.py>`_
.. image:: https://user-images.githubusercontent.com/32848391/50738954-7e891800-11d9-11e9-95aa-67c92ca6476b.gif
'''
rs = vtk.vtkParametricTorus()
rs.SetRingRadius(r)
rs.SetCrossSectionRadius(thickness)
pfs = vtk.vtkParametricFunctionSource()
pfs.SetParametricFunction(rs)
pfs.SetUResolution(res * 3)
pfs.SetVResolution(res)
pfs.Update()
nax = np.linalg.norm(axis)
if nax:
axis = np.array(axis) / nax
theta = np.arccos(axis[2])
phi = np.arctan2(axis[1], axis[0])
t = vtk.vtkTransform()
t.PostMultiply()
t.RotateY(theta * 57.3)
t.RotateZ(phi * 57.3)
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInputData(pfs.GetOutput())
tf.SetTransform(t)
tf.Update()
pd = tf.GetOutput()
actor = Actor(pd,
c=c,
alpha=alpha,
wire=wire,
legend=legend,
texture=texture)
actor.GetProperty().SetInterpolationToPhong()
actor.SetPosition(pos)
return actor
def ParametricObjects(self):
# Select one of the following functions.
parametricObject = vtk.vtkParametricTorus()
# parametricObject = vtk.vtkParametricBoy()
# parametricObject = vtk.vtkParametricConicSpiral()
# parametricObject = vtk.vtkParametricCrossCap()
# parametricObject = vtk.vtkParametricDini()
# parametricObject = vtk.vtkParametricEllipsoid()
# parametricObject = vtk.vtkParametricEnneper()
# parametricObject = vtk.vtkParametricFigure8Klein()
# parametricObject = vtk.vtkParametricKlein()
# parametricObject = vtk.vtkParametricMobius()
# parametricObject = vtk.vtkParametricRandomHills()
# parametricObject = vtk.vtkParametricRoman()
# parametricObject = vtk.vtkParametricSpline()
# parametricObject = vtk.vtkParametricSuperEllipsoid()
# parametricObject = vtk.vtkParametricSuperToroid()
# parametricObject = vtk.vtkParametricTorus()
parametricSource = vtk.vtkParametricFunctionSource()
parametricSource.SetParametricFunction(parametricObject)
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(parametricSource.GetOutputPort())
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and Interactor
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
renWin.AddRenderer(ren)
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(actor)
ren.SetBackground(1,1,1) # Background color white
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def makeSpline(self,lst):
points = vtk.vtkPoints()
for i in range(len(lst)):
v=lst[i]
points.InsertPoint(i,v[0],v[1],v[2])
spline=vtk.vtkParametricSpline()
spline.SetPoints(points)
spline.ClosedOff()
splineSource=vtk.vtkParametricFunctionSource()
splineSource.SetParametricFunction(spline)
mapper=vtk.vtkPolyDataMapper()
mapper.SetInputConnection(splineSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
def Ellipsoid(radius_x, radius_y, radius_z):
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(radius_x)
ellipsoid.SetYRadius(radius_y)
ellipsoid.SetZRadius(radius_z)
parametricSource = vtk.vtkParametricFunctionSource()
parametricSource.SetParametricFunction(ellipsoid)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(parametricSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def createLimb(self, listJoints):
listLimbPoints = self.extractStartEnd(listJoints)
for i in range(15):
transform, length = self.calcTransform(listLimbPoints[i])
self.ellipsoidPara.append(vtk.vtkParametricEllipsoid())
self.ellipsoidPara[-1].SetXRadius(self.size1)
self.ellipsoidPara[-1].SetZRadius(self.size1)
self.ellipsoidPara[-1].SetYRadius(length / 2)
self.ellipsoidSources.append(vtk.vtkParametricFunctionSource())
self.ellipsoidSources[-1].SetParametricFunction(
self.ellipsoidPara[-1])
self.ellipsoidMappers.append(vtk.vtkPolyDataMapper())
self.ellipsoidMappers[-1].SetInputConnection(
self.ellipsoidSources[-1].GetOutputPort())
self.ellipsoidActors.append(vtk.vtkActor())
self.ellipsoidActors[-1].SetMapper(self.ellipsoidMappers[-1])
self.ellipsoidActors[-1].SetUserTransform(transform)
self.ellipsoidActors[-1].GetProperty().SetColor(color)
self.ellipsoidPara[0].SetXRadius(self.size3)
self.ellipsoidPara[0].SetZRadius(self.size3)
self.ellipsoidPara[1].SetXRadius(self.size3)
self.ellipsoidPara[1].SetZRadius(self.size3)
self.ellipsoidPara[4].SetXRadius(self.size3)
self.ellipsoidPara[4].SetZRadius(self.size3)
self.ellipsoidPara[5].SetXRadius(self.size3)
self.ellipsoidPara[5].SetZRadius(self.size3)
self.ellipsoidPara[9].SetXRadius(self.size2)
self.ellipsoidPara[9].SetZRadius(self.size2)
self.ellipsoidPara[10].SetXRadius(self.size2)
self.ellipsoidPara[10].SetZRadius(self.size2)
self.ellipsoidPara[12].SetXRadius(self.size2)
self.ellipsoidPara[12].SetZRadius(self.size2)
self.ellipsoidPara[13].SetXRadius(self.size2)
self.ellipsoidPara[13].SetZRadius(self.size2)
def drawParametricSpline(self, IDList):
points = vtk.vtkPoints()
for i in IDList:
p = self.pointCloud.vtkPoints.GetPoint(i)
points.InsertNextPoint(p)
spline = vtk.vtkParametricSpline()
spline.SetPoints(points)
functionSource = vtk.vtkParametricFunctionSource()
functionSource.SetParametricFunction(spline)
functionSource.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(functionSource.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.renderer.AddActor(actor)
self.refresh_renderer()
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.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create three points.
origin = [0.0, 0.0, 0.0]
p0 = [1.0, 0.0, 0.0]
p1 = [0.0, 1.0, 0.0]
p2 = [0.0, 1.0, 2.0]
p3 = [1.0, 2.0, 3.0]
# Create a vtkPoints object and store the points in it.
points = vtk.vtkPoints()
points.InsertNextPoint(origin)
points.InsertNextPoint(p0)
points.InsertNextPoint(p1)
points.InsertNextPoint(p2)
points.InsertNextPoint(p3)
spline = vtk.vtkParametricSpline()
spline.SetPoints(points)
functionSource = vtk.vtkParametricFunctionSource()
functionSource.SetParametricFunction(spline)
functionSource.Update()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(functionSource.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
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.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
pointSource = vtk.vtkPointSource()
pointSource.SetNumberOfPoints(5)
pointSource.Update()
points = pointSource.GetOutput().GetPoints()
xSpline = vtk.vtkKochanekSpline()
ySpline = vtk.vtkKochanekSpline()
zSpline = vtk.vtkKochanekSpline()
spline = vtk.vtkParametricSpline()
spline.SetXSpline(xSpline)
spline.SetYSpline(ySpline)
spline.SetZSpline(zSpline)
spline.SetPoints(points)
functionSource = vtk.vtkParametricFunctionSource()
functionSource.SetParametricFunction(spline)
functionSource.Update()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(functionSource.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def MakeBoys():
'''
Make a parametric surface as the source.
:return: vtkPolyData with normal and scalar data.
'''
fn = vtk.vtkParametricBoy()
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(fn)
source.SetUResolution(50)
source.SetVResolution(50)
source.SetScalarModeToZ()
source.Update()
# Name the arrays (not needed in VTK 6.2+ for vtkParametricFunctionSource)
source.GetOutput().GetPointData().GetNormals().SetName('Normals')
# We have calculated the elevation, just rename the scalars.
source.GetOutput().GetPointData().GetScalars().SetName('Elevation')
return CalculateCurvatures(source.GetOutput())
def MakeParametricSource():
'''
Make a parametric surface as the source.
:return: vtkPolyData with normal and scalar data.
'''
fn = vtk.vtkParametricRandomHills()
fn.AllowRandomGenerationOn()
fn.SetRandomSeed(1)
fn.SetNumberOfHills(30)
if fn.GetClassName() == 'vtkParametricRandomHills':
# Make the normals face out of the surface.
fn.ClockwiseOrderingOff()
source = vtk.vtkParametricFunctionSource()
source.SetParametricFunction(fn)
source.SetUResolution(50)
source.SetVResolution(50)
source.SetScalarModeToZ()
source.Update()
# Name the arrays (not needed in VTK 6.2+ for vtkParametricFunctionSource)
source.GetOutput().GetPointData().GetNormals().SetName('Normals')
source.GetOutput().GetPointData().GetScalars().SetName('Scalars')
return source.GetOutput()
def __init__(self, r1=1, r2=0.25, center=(0,0,0), rotXYZ=(0,0,0), color=(1,0,0)):
self.parfun = vtk.vtkParametricSuperToroid()
self.parfun.SetRingRadius(r1)
self.parfun.SetCrossSectionRadius(r2)
self.parfun.SetN1(1)
self.parfun.SetN2(1)
self.src = vtk.vtkParametricFunctionSource()
self.src.SetParametricFunction(self.parfun)
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2])
transform.RotateX(rotXYZ[0])
transform.RotateY(rotXYZ[1])
transform.RotateZ(rotXYZ[2])
transformFilter=vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(self.src.GetOutputPort())
transformFilter.Update()
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInput(transformFilter.GetOutput())
self.SetMapper(self.mapper)
self.SetColor(color)
textureReader = vtk.vtkJPEGReader()
textureReader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/beach.jpg")
texture = vtk.vtkTexture()
texture.SetInputConnection(textureReader.GetOutputPort())
# ------------------------------------------------------------
# For each parametric surface:
# 1) Create it
# 2) Assign mappers and actors
# 3) Position ths object
# 5) Add a label
# ------------------------------------------------------------
# ------------------------------------------------------------
# Create a torus
# ------------------------------------------------------------
torus = vtk.vtkParametricTorus()
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusMapper = vtk.vtkPolyDataMapper()
torusMapper.SetInputConnection(torusSource.GetOutputPort())
torusMapper.SetScalarRange(0,360)
torusActor = vtk.vtkActor()
torusActor.SetMapper(torusMapper)
torusActor.SetPosition(0,12,0)
torusTextMapper = vtk.vtkTextMapper()
torusTextMapper.SetInput("Torus")
torusTextMapper.GetTextProperty().SetJustificationToCentered()
torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
torusTextMapper.GetTextProperty().SetColor(1,0,0)
torusTextMapper.GetTextProperty().SetFontSize(14)
torusTextActor = vtk.vtkActor2D()
def testParametricFunctions(self):
# ------------------------------------------------------------
# Get a texture
# ------------------------------------------------------------
textureReader = vtk.vtkJPEGReader()
textureReader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg")
texture = vtk.vtkTexture()
texture.SetInputConnection(textureReader.GetOutputPort())
# ------------------------------------------------------------
# For each parametric surface:
# 1) Create it
# 2) Assign mappers and actors
# 3) Position the object
# 5) Add a label
# ------------------------------------------------------------
# ------------------------------------------------------------
# Create a torus
# ------------------------------------------------------------
torus = vtk.vtkParametricTorus()
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusMapper = vtk.vtkPolyDataMapper()
torusMapper.SetInputConnection(torusSource.GetOutputPort())
torusMapper.SetScalarRange(0, 360)
torusActor = vtk.vtkActor()
torusActor.SetMapper(torusMapper)
torusActor.SetPosition(0, 12, 0)
torusTextMapper = vtk.vtkTextMapper()
torusTextMapper.SetInput("Torus")
torusTextMapper.GetTextProperty().SetJustificationToCentered()
torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
torusTextMapper.GetTextProperty().SetColor(1, 0, 0)
torusTextMapper.GetTextProperty().SetFontSize(14)
torusTextActor = vtk.vtkActor2D()
torusTextActor.SetMapper(torusTextMapper)
torusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
torusTextActor.GetPositionCoordinate().SetValue(0, 9.5, 0)
# ------------------------------------------------------------
# Create a Klein bottle
# ------------------------------------------------------------
klein = vtk.vtkParametricKlein()
kleinSource = vtk.vtkParametricFunctionSource()
kleinSource.SetParametricFunction(klein)
kleinSource.SetScalarModeToU0V0()
kleinMapper = vtk.vtkPolyDataMapper()
kleinMapper.SetInputConnection(kleinSource.GetOutputPort())
kleinMapper.SetScalarRange(0, 3)
kleinActor = vtk.vtkActor()
kleinActor.SetMapper(kleinMapper)
kleinActor.SetPosition(8, 10.5, 0)
kleinTextMapper = vtk.vtkTextMapper()
kleinTextMapper.SetInput("Klein")
kleinTextMapper.GetTextProperty().SetJustificationToCentered()
kleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
kleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
kleinTextMapper.GetTextProperty().SetFontSize(14)
kleinTextActor = vtk.vtkActor2D()
kleinTextActor.SetMapper(kleinTextMapper)
kleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
kleinTextActor.GetPositionCoordinate().SetValue(8, 9.5, 0)
# ------------------------------------------------------------
# Create a Figure-8 Klein
# ------------------------------------------------------------
klein2 = vtk.vtkParametricFigure8Klein()
klein2Source = vtk.vtkParametricFunctionSource()
klein2Source.SetParametricFunction(klein2)
klein2Source.GenerateTextureCoordinatesOn()
klein2Mapper = vtk.vtkPolyDataMapper()
klein2Mapper.SetInputConnection(klein2Source.GetOutputPort())
klein2Mapper.SetScalarRange(0, 3)
klein2Actor = vtk.vtkActor()
klein2Actor.SetMapper(klein2Mapper)
klein2Actor.SetPosition(16, 12, 0)
klein2Actor.SetTexture(texture)
fig8KleinTextMapper = vtk.vtkTextMapper()
fig8KleinTextMapper.SetInput("Fig-8.Klein")
fig8KleinTextMapper.GetTextProperty().SetJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
fig8KleinTextMapper.GetTextProperty().SetFontSize(14)
fig8KleinTextActor = vtk.vtkActor2D()
fig8KleinTextActor.SetMapper(fig8KleinTextMapper)
fig8KleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
fig8KleinTextActor.GetPositionCoordinate().SetValue(16, 9.5, 0)
# ------------------------------------------------------------
# Create a Mobius strip
# ------------------------------------------------------------
mobius = vtk.vtkParametricMobius()
mobiusSource = vtk.vtkParametricFunctionSource()
mobiusSource.SetParametricFunction(mobius)
mobiusSource.GenerateTextureCoordinatesOn()
mobiusMapper = vtk.vtkPolyDataMapper()
mobiusMapper.SetInputConnection(mobiusSource.GetOutputPort())
mobiusActor = vtk.vtkActor()
mobiusActor.SetMapper(mobiusMapper)
mobiusActor.RotateX(45)
mobiusActor.SetPosition(24, 12, 0)
mobiusActor.SetTexture(texture)
mobiusTextMapper = vtk.vtkTextMapper()
mobiusTextMapper.SetInput("Mobius")
mobiusTextMapper.GetTextProperty().SetJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetColor(1, 0, 0)
mobiusTextMapper.GetTextProperty().SetFontSize(14)
mobiusTextActor = vtk.vtkActor2D()
mobiusTextActor.SetMapper(mobiusTextMapper)
mobiusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
mobiusTextActor.GetPositionCoordinate().SetValue(24, 9.5, 0)
# ------------------------------------------------------------
# Create a super toroid
# ------------------------------------------------------------
toroid = vtk.vtkParametricSuperToroid()
toroid.SetN1(2)
toroid.SetN2(3)
toroidSource = vtk.vtkParametricFunctionSource()
toroidSource.SetParametricFunction(toroid)
toroidSource.SetScalarModeToU()
toroidMapper = vtk.vtkPolyDataMapper()
toroidMapper.SetInputConnection(toroidSource.GetOutputPort())
toroidMapper.SetScalarRange(0, 6.28)
toroidActor = vtk.vtkActor()
toroidActor.SetMapper(toroidMapper)
toroidActor.SetPosition(0, 4, 0)
superToroidTextMapper = vtk.vtkTextMapper()
superToroidTextMapper.SetInput("Super.Toroid")
superToroidTextMapper.GetTextProperty().SetJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superToroidTextMapper.GetTextProperty().SetFontSize(14)
superToroidTextActor = vtk.vtkActor2D()
superToroidTextActor.SetMapper(superToroidTextMapper)
superToroidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superToroidTextActor.GetPositionCoordinate().SetValue(0, 1.5, 0)
# ------------------------------------------------------------
# Create a super ellipsoid
# ------------------------------------------------------------
superEllipsoid = vtk.vtkParametricSuperEllipsoid()
superEllipsoid.SetXRadius(1.25)
superEllipsoid.SetYRadius(1.5)
superEllipsoid.SetZRadius(1.0)
superEllipsoid.SetN1(1.1)
superEllipsoid.SetN2(1.75)
superEllipsoidSource = vtk.vtkParametricFunctionSource()
superEllipsoidSource.SetParametricFunction(superEllipsoid)
superEllipsoidSource.SetScalarModeToV()
superEllipsoidMapper = vtk.vtkPolyDataMapper()
superEllipsoidMapper.SetInputConnection(superEllipsoidSource.GetOutputPort())
superEllipsoidMapper.SetScalarRange(0, 3.14)
superEllipsoidActor = vtk.vtkActor()
superEllipsoidActor.SetMapper(superEllipsoidMapper)
superEllipsoidActor.SetPosition(8, 4, 0)
superEllipsoidTextMapper = vtk.vtkTextMapper()
superEllipsoidTextMapper.SetInput("Super.Ellipsoid")
superEllipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superEllipsoidTextMapper.GetTextProperty().SetFontSize(14)
superEllipsoidTextActor = vtk.vtkActor2D()
superEllipsoidTextActor.SetMapper(superEllipsoidTextMapper)
superEllipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superEllipsoidTextActor.GetPositionCoordinate().SetValue(8, 1.5, 0)
# ------------------------------------------------------------
# Create an open 1D spline
# ------------------------------------------------------------
splinePoints = [
[0.50380158308139134, -0.60679315105396936, -0.37248976406291578],
[-0.4354646054261665, -0.85362339758017258, -0.84844312996065385],
[0.2163147512899315, -0.39797507012168643, -0.76700353518454523],
[0.97158415334838644, -0.58513467367046257, -0.35846037946569753],
[-0.64359767997804918, -0.94620739107309249, -0.90762176546623086],
[-0.39901219094126117, -0.1978931497772658, 0.0098316934936828471],
[-0.75872745167404765, 0.067719714281950116, 0.165237936733867],
[-0.84599731389712418, -0.67685466896596114, 0.10357868909071133],
[0.84702754758625654, -0.0080077177882230677, -0.58571286666473044],
[-0.076150034124101484, 0.14637647622561856, 0.1494359239700418] ]
inputPoints = vtk.vtkPoints()
for i in range(0, 10):
inputPoints.InsertPoint(i, splinePoints[i])
spline = vtk.vtkParametricSpline()
spline.SetPoints(inputPoints)
spline.ClosedOff()
splineSource = vtk.vtkParametricFunctionSource()
splineSource.SetParametricFunction(spline)
splineMapper = vtk.vtkPolyDataMapper()
splineMapper.SetInputConnection(splineSource.GetOutputPort())
splineActor = vtk.vtkActor()
splineActor.SetMapper(splineMapper)
splineActor.SetPosition(16, 4, 0)
splineActor.GetProperty().SetColor(0, 0, 0)
splineTextMapper = vtk.vtkTextMapper()
splineTextMapper.SetInput("Open.Spline")
splineTextMapper.GetTextProperty().SetJustificationToCentered()
splineTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
splineTextMapper.GetTextProperty().SetColor(1, 0, 0)
splineTextMapper.GetTextProperty().SetFontSize(14)
splineTextActor = vtk.vtkActor2D()
splineTextActor.SetMapper(splineTextMapper)
splineTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
splineTextActor.GetPositionCoordinate().SetValue(16, 1.5, 0)
# ------------------------------------------------------------
# Create a closed 1D spline
# ------------------------------------------------------------
spline2 = vtk.vtkParametricSpline()
spline2.SetPoints(inputPoints)
spline2.ClosedOn()
spline2Source = vtk.vtkParametricFunctionSource()
spline2Source.SetParametricFunction(spline2)
spline2Mapper = vtk.vtkPolyDataMapper()
spline2Mapper.SetInputConnection(spline2Source.GetOutputPort())
spline2Actor = vtk.vtkActor()
spline2Actor.SetMapper(spline2Mapper)
spline2Actor.SetPosition(24, 4, 0)
spline2Actor.GetProperty().SetColor(0, 0, 0)
spline2TextMapper = vtk.vtkTextMapper()
spline2TextMapper.SetInput("Closed.Spline")
spline2TextMapper.GetTextProperty().SetJustificationToCentered()
spline2TextMapper.GetTextProperty().SetVerticalJustificationToCentered()
spline2TextMapper.GetTextProperty().SetColor(1, 0, 0)
spline2TextMapper.GetTextProperty().SetFontSize(14)
spline2TextActor = vtk.vtkActor2D()
spline2TextActor.SetMapper(spline2TextMapper)
spline2TextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
spline2TextActor.GetPositionCoordinate().SetValue(24, 1.5, 0)
# ------------------------------------------------------------
# Create a spiral conic
# ------------------------------------------------------------
sconic = vtk.vtkParametricConicSpiral()
sconic.SetA(0.8)
sconic.SetB(2.5)
sconic.SetC(0.4)
sconicSource = vtk.vtkParametricFunctionSource()
sconicSource.SetParametricFunction(sconic)
sconicSource.SetScalarModeToDistance()
sconicMapper = vtk.vtkPolyDataMapper()
sconicMapper.SetInputConnection(sconicSource.GetOutputPort())
sconicActor = vtk.vtkActor()
sconicActor.SetMapper(sconicMapper)
sconicMapper.SetScalarRange(0, 9)
sconicActor.SetPosition(0, -4, 0)
sconicActor.SetScale(1.2, 1.2, 1.2)
sconicTextMapper = vtk.vtkTextMapper()
sconicTextMapper.SetInput("Spiral.Conic")
sconicTextMapper.GetTextProperty().SetJustificationToCentered()
sconicTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
sconicTextMapper.GetTextProperty().SetColor(1, 0, 0)
sconicTextMapper.GetTextProperty().SetFontSize(14)
sconicTextActor = vtk.vtkActor2D()
sconicTextActor.SetMapper(sconicTextMapper)
sconicTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
sconicTextActor.GetPositionCoordinate().SetValue(0, -6.5, 0)
# ------------------------------------------------------------
# Create Boy's surface
# ------------------------------------------------------------
boy = vtk.vtkParametricBoy()
boySource = vtk.vtkParametricFunctionSource()
boySource.SetParametricFunction(boy)
boySource.SetScalarModeToModulus()
boyMapper = vtk.vtkPolyDataMapper()
boyMapper.SetInputConnection(boySource.GetOutputPort())
boyMapper.SetScalarRange(0, 2)
boyActor = vtk.vtkActor()
boyActor.SetMapper(boyMapper)
boyActor.SetPosition(8, -4, 0)
boyActor.SetScale(1.5, 1.5, 1.5)
boyTextMapper = vtk.vtkTextMapper()
boyTextMapper.SetInput("Boy")
boyTextMapper.GetTextProperty().SetJustificationToCentered()
boyTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
boyTextMapper.GetTextProperty().SetColor(1, 0, 0)
boyTextMapper.GetTextProperty().SetFontSize(14)
boyTextActor = vtk.vtkActor2D()
boyTextActor.SetMapper(boyTextMapper)
boyTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
boyTextActor.GetPositionCoordinate().SetValue(8, -6.5, 0)
# ------------------------------------------------------------
# Create a cross cap
# ------------------------------------------------------------
crossCap = vtk.vtkParametricCrossCap()
crossCapSource = vtk.vtkParametricFunctionSource()
crossCapSource.SetParametricFunction(crossCap)
crossCapSource.SetScalarModeToY()
crossCapMapper = vtk.vtkPolyDataMapper()
crossCapMapper.SetInputConnection(crossCapSource.GetOutputPort())
crossCapActor = vtk.vtkActor()
crossCapActor.SetMapper(crossCapMapper)
crossCapActor.RotateX(65)
crossCapActor.SetPosition(16, -4, 0)
crossCapActor.SetScale(1.5, 1.5, 1.5)
crossCapTextMapper = vtk.vtkTextMapper()
crossCapTextMapper.SetInput("Cross.Cap")
crossCapTextMapper.GetTextProperty().SetJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetColor(1, 0, 0)
crossCapTextMapper.GetTextProperty().SetFontSize(14)
crossCapTextActor = vtk.vtkActor2D()
crossCapTextActor.SetMapper(crossCapTextMapper)
crossCapTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
crossCapTextActor.GetPositionCoordinate().SetValue(16, -6.5, 0)
# ------------------------------------------------------------
# Create Dini's surface
# ------------------------------------------------------------
dini = vtk.vtkParametricDini()
diniSource = vtk.vtkParametricFunctionSource()
diniSource.SetScalarModeToDistance()
diniSource.SetParametricFunction(dini)
diniMapper = vtk.vtkPolyDataMapper()
diniMapper.SetInputConnection(diniSource.GetOutputPort())
diniActor = vtk.vtkActor()
diniActor.SetMapper(diniMapper)
diniActor.RotateX(-90)
diniActor.SetPosition(24, -3, 0)
diniActor.SetScale(1.5, 1.5, 0.5)
diniTextMapper = vtk.vtkTextMapper()
diniTextMapper.SetInput("Dini")
diniTextMapper.GetTextProperty().SetJustificationToCentered()
diniTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
diniTextMapper.GetTextProperty().SetColor(1, 0, 0)
diniTextMapper.GetTextProperty().SetFontSize(14)
diniTextActor = vtk.vtkActor2D()
diniTextActor.SetMapper(diniTextMapper)
diniTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
diniTextActor.GetPositionCoordinate().SetValue(24, -6.5, 0)
# ------------------------------------------------------------
# Create Enneper's surface
# ------------------------------------------------------------
enneper = vtk.vtkParametricEnneper()
enneperSource = vtk.vtkParametricFunctionSource()
enneperSource.SetParametricFunction(enneper)
enneperSource.SetScalarModeToQuadrant()
enneperMapper = vtk.vtkPolyDataMapper()
enneperMapper.SetInputConnection(enneperSource.GetOutputPort())
enneperMapper.SetScalarRange(1, 4)
enneperActor = vtk.vtkActor()
enneperActor.SetMapper(enneperMapper)
enneperActor.SetPosition(0, -12, 0)
enneperActor.SetScale(0.25, 0.25, 0.25)
enneperTextMapper = vtk.vtkTextMapper()
enneperTextMapper.SetInput("Enneper")
enneperTextMapper.GetTextProperty().SetJustificationToCentered()
enneperTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
enneperTextMapper.GetTextProperty().SetColor(1, 0, 0)
enneperTextMapper.GetTextProperty().SetFontSize(14)
enneperTextActor = vtk.vtkActor2D()
enneperTextActor.SetMapper(enneperTextMapper)
enneperTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
enneperTextActor.GetPositionCoordinate().SetValue(0, -14.5, 0)
# ------------------------------------------------------------
# Create an ellipsoidal surface
# ------------------------------------------------------------
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(1)
ellipsoid.SetYRadius(0.75)
ellipsoid.SetZRadius(0.5)
ellipsoidSource = vtk.vtkParametricFunctionSource()
ellipsoidSource.SetParametricFunction(ellipsoid)
ellipsoidSource.SetScalarModeToZ()
ellipsoidMapper = vtk.vtkPolyDataMapper()
ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort())
ellipsoidMapper.SetScalarRange(-0.5, 0.5)
ellipsoidActor = vtk.vtkActor()
ellipsoidActor.SetMapper(ellipsoidMapper)
ellipsoidActor.SetPosition(8, -12, 0)
ellipsoidActor.SetScale(1.5, 1.5, 1.5)
ellipsoidTextMapper = vtk.vtkTextMapper()
ellipsoidTextMapper.SetInput("Ellipsoid")
ellipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
ellipsoidTextMapper.GetTextProperty().SetFontSize(14)
ellipsoidTextActor = vtk.vtkActor2D()
ellipsoidTextActor.SetMapper(ellipsoidTextMapper)
ellipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
ellipsoidTextActor.GetPositionCoordinate().SetValue(8, -14.5, 0)
# ------------------------------------------------------------
# Create a surface with random hills on it.
# ------------------------------------------------------------
randomHills = vtk.vtkParametricRandomHills()
randomHills.AllowRandomGenerationOn()
randomHillsSource = vtk.vtkParametricFunctionSource()
randomHillsSource.SetParametricFunction(randomHills)
randomHillsSource.GenerateTextureCoordinatesOn()
randomHillsMapper = vtk.vtkPolyDataMapper()
randomHillsMapper.SetInputConnection(randomHillsSource.GetOutputPort())
randomHillsActor = vtk.vtkActor()
randomHillsActor.SetMapper(randomHillsMapper)
randomHillsActor.SetPosition(16, -14, 0)
randomHillsActor.SetScale(0.2, 0.2, 0.2)
randomHillsActor.SetTexture(texture)
randomHillsTextMapper = vtk.vtkTextMapper()
randomHillsTextMapper.SetInput("Random.Hills")
randomHillsTextMapper.GetTextProperty().SetJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetColor(1, 0, 0)
randomHillsTextMapper.GetTextProperty().SetFontSize(14)
randomHillsTextActor = vtk.vtkActor2D()
randomHillsTextActor.SetMapper(randomHillsTextMapper)
randomHillsTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
randomHillsTextActor.GetPositionCoordinate().SetValue(16, -14.5, 0)
# ------------------------------------------------------------
# Create Steiner's Roman Surface.
# ------------------------------------------------------------
roman = vtk.vtkParametricRoman()
roman.SetRadius(1.5)
romanSource = vtk.vtkParametricFunctionSource()
romanSource.SetParametricFunction(roman)
romanSource.SetScalarModeToX()
romanMapper = vtk.vtkPolyDataMapper()
romanMapper.SetInputConnection(romanSource.GetOutputPort())
romanActor = vtk.vtkActor()
romanActor.SetMapper(romanMapper)
romanActor.SetPosition(24, -12, 0)
romanTextMapper = vtk.vtkTextMapper()
romanTextMapper.SetInput("Roman")
romanTextMapper.GetTextProperty().SetJustificationToCentered()
romanTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
romanTextMapper.GetTextProperty().SetColor(1, 0, 0)
romanTextMapper.GetTextProperty().SetFontSize(14)
romanTextActor = vtk.vtkActor2D()
romanTextActor.SetMapper(romanTextMapper)
romanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
romanTextActor.GetPositionCoordinate().SetValue(24, -14.5, 0)
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and both Actors
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(torusActor)
ren.AddViewProp(kleinActor)
ren.AddViewProp(klein2Actor)
ren.AddViewProp(toroidActor)
ren.AddViewProp(superEllipsoidActor)
ren.AddViewProp(mobiusActor)
ren.AddViewProp(splineActor)
ren.AddViewProp(spline2Actor)
ren.AddViewProp(sconicActor)
ren.AddViewProp(boyActor)
ren.AddViewProp(crossCapActor)
ren.AddViewProp(diniActor)
ren.AddViewProp(enneperActor)
ren.AddViewProp(ellipsoidActor)
ren.AddViewProp(randomHillsActor)
ren.AddViewProp(romanActor)
#add text actors
ren.AddViewProp(torusTextActor)
ren.AddViewProp(kleinTextActor)
ren.AddViewProp(fig8KleinTextActor)
ren.AddViewProp(mobiusTextActor)
ren.AddViewProp(superToroidTextActor)
ren.AddViewProp(superEllipsoidTextActor)
ren.AddViewProp(splineTextActor)
ren.AddViewProp(spline2TextActor)
ren.AddViewProp(sconicTextActor)
ren.AddViewProp(boyTextActor)
ren.AddViewProp(crossCapTextActor)
ren.AddViewProp(diniTextActor)
ren.AddViewProp(enneperTextActor)
ren.AddViewProp(ellipsoidTextActor)
ren.AddViewProp(randomHillsTextActor)
ren.AddViewProp(romanTextActor)
ren.SetBackground(0.7, 0.8, 1)
renWin.SetSize(500, 500)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1.3)
iren.Initialize()
renWin.Render()
img_file = "TestParametricFunctions.png"
# NOTE: this test has a companion .tcl test. The threshold set
# here should be the same as the threshold in the .tcl
# test. Both tests should produce exactly the same results.
vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10)
vtk.test.Testing.interact()
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 testParametricFunctions(self):
# ------------------------------------------------------------
# Get a texture
# ------------------------------------------------------------
textureReader = vtk.vtkJPEGReader()
textureReader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg")
texture = vtk.vtkTexture()
texture.SetInputConnection(textureReader.GetOutputPort())
# ------------------------------------------------------------
# For each parametric surface:
# 1) Create it
# 2) Assign mappers and actors
# 3) Position this object
# 5) Add a label
# ------------------------------------------------------------
# ------------------------------------------------------------
# Create a torus
# ------------------------------------------------------------
torus = vtk.vtkParametricTorus()
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusMapper = vtk.vtkPolyDataMapper()
torusMapper.SetInputConnection(torusSource.GetOutputPort())
torusMapper.SetScalarRange(0, 360)
torusActor = vtk.vtkActor()
torusActor.SetMapper(torusMapper)
torusActor.SetPosition(0, 12, 0)
torusTextMapper = vtk.vtkTextMapper()
torusTextMapper.SetInput("Torus")
torusTextMapper.GetTextProperty().SetJustificationToCentered()
torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
torusTextMapper.GetTextProperty().SetColor(1, 0, 0)
torusTextMapper.GetTextProperty().SetFontSize(14)
torusTextActor = vtk.vtkActor2D()
torusTextActor.SetMapper(torusTextMapper)
torusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
torusTextActor.GetPositionCoordinate().SetValue(0, 9.5, 0)
# ------------------------------------------------------------
# Create a klein bottle
# ------------------------------------------------------------
klein = vtk.vtkParametricKlein()
kleinSource = vtk.vtkParametricFunctionSource()
kleinSource.SetParametricFunction(klein)
kleinSource.SetScalarModeToU0V0()
kleinMapper = vtk.vtkPolyDataMapper()
kleinMapper.SetInputConnection(kleinSource.GetOutputPort())
kleinMapper.SetScalarRange(0, 3)
kleinActor = vtk.vtkActor()
kleinActor.SetMapper(kleinMapper)
kleinActor.SetPosition(8, 10.5, 0)
kleinTextMapper = vtk.vtkTextMapper()
kleinTextMapper.SetInput("Klein")
kleinTextMapper.GetTextProperty().SetJustificationToCentered()
kleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
kleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
kleinTextMapper.GetTextProperty().SetFontSize(14)
kleinTextActor = vtk.vtkActor2D()
kleinTextActor.SetMapper(kleinTextMapper)
kleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
kleinTextActor.GetPositionCoordinate().SetValue(8, 9.5, 0)
# ------------------------------------------------------------
# Create a Figure-8 Klein
# ------------------------------------------------------------
klein2 = vtk.vtkParametricFigure8Klein()
klein2Source = vtk.vtkParametricFunctionSource()
klein2Source.SetParametricFunction(klein2)
klein2Source.GenerateTextureCoordinatesOn()
klein2Mapper = vtk.vtkPolyDataMapper()
klein2Mapper.SetInputConnection(klein2Source.GetOutputPort())
klein2Mapper.SetScalarRange(0, 3)
klein2Actor = vtk.vtkActor()
klein2Actor.SetMapper(klein2Mapper)
klein2Actor.SetPosition(16, 12, 0)
klein2Actor.SetTexture(texture)
fig8KleinTextMapper = vtk.vtkTextMapper()
fig8KleinTextMapper.SetInput("Fig-8.Klein")
fig8KleinTextMapper.GetTextProperty().SetJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
fig8KleinTextMapper.GetTextProperty().SetFontSize(14)
fig8KleinTextActor = vtk.vtkActor2D()
fig8KleinTextActor.SetMapper(fig8KleinTextMapper)
fig8KleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
fig8KleinTextActor.GetPositionCoordinate().SetValue(16, 9.5, 0)
# ------------------------------------------------------------
# Create a mobius strip
# ------------------------------------------------------------
mobius = vtk.vtkParametricMobius()
mobiusSource = vtk.vtkParametricFunctionSource()
mobiusSource.SetParametricFunction(mobius)
mobiusSource.GenerateTextureCoordinatesOn()
mobiusMapper = vtk.vtkPolyDataMapper()
mobiusMapper.SetInputConnection(mobiusSource.GetOutputPort())
mobiusActor = vtk.vtkActor()
mobiusActor.SetMapper(mobiusMapper)
mobiusActor.RotateX(45)
mobiusActor.SetPosition(24, 12, 0)
mobiusActor.SetTexture(texture)
mobiusTextMapper = vtk.vtkTextMapper()
mobiusTextMapper.SetInput("Mobius")
mobiusTextMapper.GetTextProperty().SetJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetColor(1, 0, 0)
mobiusTextMapper.GetTextProperty().SetFontSize(14)
mobiusTextActor = vtk.vtkActor2D()
mobiusTextActor.SetMapper(mobiusTextMapper)
mobiusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
mobiusTextActor.GetPositionCoordinate().SetValue(24, 9.5, 0)
# ------------------------------------------------------------
# Create a super toroid
# ------------------------------------------------------------
toroid = vtk.vtkParametricSuperToroid()
toroid.SetN1(2)
toroid.SetN2(3)
toroidSource = vtk.vtkParametricFunctionSource()
toroidSource.SetParametricFunction(toroid)
toroidSource.SetScalarModeToU()
toroidMapper = vtk.vtkPolyDataMapper()
toroidMapper.SetInputConnection(toroidSource.GetOutputPort())
toroidMapper.SetScalarRange(0, 6.28)
toroidActor = vtk.vtkActor()
toroidActor.SetMapper(toroidMapper)
toroidActor.SetPosition(0, 4, 0)
superToroidTextMapper = vtk.vtkTextMapper()
superToroidTextMapper.SetInput("Super.Toroid")
superToroidTextMapper.GetTextProperty().SetJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superToroidTextMapper.GetTextProperty().SetFontSize(14)
superToroidTextActor = vtk.vtkActor2D()
superToroidTextActor.SetMapper(superToroidTextMapper)
superToroidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superToroidTextActor.GetPositionCoordinate().SetValue(0, 1.5, 0)
# ------------------------------------------------------------
# Create a super ellipsoid
# ------------------------------------------------------------
superEllipsoid = vtk.vtkParametricSuperEllipsoid()
superEllipsoid.SetXRadius(1.25)
superEllipsoid.SetYRadius(1.5)
superEllipsoid.SetZRadius(1.0)
superEllipsoid.SetN1(1.1)
superEllipsoid.SetN2(1.75)
superEllipsoidSource = vtk.vtkParametricFunctionSource()
superEllipsoidSource.SetParametricFunction(superEllipsoid)
superEllipsoidSource.SetScalarModeToV()
superEllipsoidMapper = vtk.vtkPolyDataMapper()
superEllipsoidMapper.SetInputConnection(superEllipsoidSource.GetOutputPort())
superEllipsoidMapper.SetScalarRange(0, 3.14)
superEllipsoidActor = vtk.vtkActor()
superEllipsoidActor.SetMapper(superEllipsoidMapper)
superEllipsoidActor.SetPosition(8, 4, 0)
superEllipsoidTextMapper = vtk.vtkTextMapper()
superEllipsoidTextMapper.SetInput("Super.Ellipsoid")
superEllipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superEllipsoidTextMapper.GetTextProperty().SetFontSize(14)
superEllipsoidTextActor = vtk.vtkActor2D()
superEllipsoidTextActor.SetMapper(superEllipsoidTextMapper)
superEllipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superEllipsoidTextActor.GetPositionCoordinate().SetValue(8, 1.5, 0)
# ------------------------------------------------------------
# Create an open 1D spline
# ------------------------------------------------------------
splinePoints = [[ -0.981576726763 , 0.639953289013 , -0.305071552892 ],
[ 0.6624105478 , -0.865923131754 , 0.429924616325 ],
[ -0.2569734311 , -0.952456491977 , 0.0637393393851 ],
[ -0.732922955292 , -0.236109588871 , -0.293860152035 ],
[ -0.907575251492 , 0.382748181644 , 0.848688894812 ],
[ -0.0857448890273 , 0.885650117828 , -0.878469658959 ],
[ -0.439558122977 , 0.346627118693 , -0.238016126323 ],
[ -0.337035103392 , -0.548982715024 , -0.752491410706 ],
[ 0.876860257181 , -0.609657562156 , -0.514647156705 ],
[ 0.325237251504 , 0.26248602721 , -0.397340677398 ]]
inputPoints = vtk.vtkPoints()
for i in range(0, 10):
inputPoints.InsertPoint(i, splinePoints[i])
spline = vtk.vtkParametricSpline()
spline.SetPoints(inputPoints)
spline.ClosedOff()
splineSource = vtk.vtkParametricFunctionSource()
splineSource.SetParametricFunction(spline)
splineMapper = vtk.vtkPolyDataMapper()
splineMapper.SetInputConnection(splineSource.GetOutputPort())
splineActor = vtk.vtkActor()
splineActor.SetMapper(splineMapper)
splineActor.SetPosition(16, 4, 0)
splineActor.GetProperty().SetColor(0, 0, 0)
splineTextMapper = vtk.vtkTextMapper()
splineTextMapper.SetInput("Open.Spline")
splineTextMapper.GetTextProperty().SetJustificationToCentered()
splineTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
splineTextMapper.GetTextProperty().SetColor(1, 0, 0)
splineTextMapper.GetTextProperty().SetFontSize(14)
splineTextActor = vtk.vtkActor2D()
splineTextActor.SetMapper(splineTextMapper)
splineTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
splineTextActor.GetPositionCoordinate().SetValue(16, 1.5, 0)
# ------------------------------------------------------------
# Create a closed 1D spline
# ------------------------------------------------------------
spline2 = vtk.vtkParametricSpline()
spline2.SetPoints(inputPoints)
spline2.ClosedOn()
spline2Source = vtk.vtkParametricFunctionSource()
spline2Source.SetParametricFunction(spline2)
spline2Mapper = vtk.vtkPolyDataMapper()
spline2Mapper.SetInputConnection(spline2Source.GetOutputPort())
spline2Actor = vtk.vtkActor()
spline2Actor.SetMapper(spline2Mapper)
spline2Actor.SetPosition(24, 4, 0)
spline2Actor.GetProperty().SetColor(0, 0, 0)
spline2TextMapper = vtk.vtkTextMapper()
spline2TextMapper.SetInput("Closed.Spline")
spline2TextMapper.GetTextProperty().SetJustificationToCentered()
spline2TextMapper.GetTextProperty().SetVerticalJustificationToCentered()
spline2TextMapper.GetTextProperty().SetColor(1, 0, 0)
spline2TextMapper.GetTextProperty().SetFontSize(14)
spline2TextActor = vtk.vtkActor2D()
spline2TextActor.SetMapper(spline2TextMapper)
spline2TextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
spline2TextActor.GetPositionCoordinate().SetValue(24, 1.5, 0)
# ------------------------------------------------------------
# Create a spiral conic
# ------------------------------------------------------------
sconic = vtk.vtkParametricConicSpiral()
sconic.SetA(0.8)
sconic.SetB(2.5)
sconic.SetC(0.4)
sconicSource = vtk.vtkParametricFunctionSource()
sconicSource.SetParametricFunction(sconic)
sconicSource.SetScalarModeToDistance()
sconicMapper = vtk.vtkPolyDataMapper()
sconicMapper.SetInputConnection(sconicSource.GetOutputPort())
sconicActor = vtk.vtkActor()
sconicActor.SetMapper(sconicMapper)
sconicMapper.SetScalarRange(0, 9)
sconicActor.SetPosition(0, -4, 0)
sconicActor.SetScale(1.2, 1.2, 1.2)
sconicTextMapper = vtk.vtkTextMapper()
sconicTextMapper.SetInput("Spiral.Conic")
sconicTextMapper.GetTextProperty().SetJustificationToCentered()
sconicTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
sconicTextMapper.GetTextProperty().SetColor(1, 0, 0)
sconicTextMapper.GetTextProperty().SetFontSize(14)
sconicTextActor = vtk.vtkActor2D()
sconicTextActor.SetMapper(sconicTextMapper)
sconicTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
sconicTextActor.GetPositionCoordinate().SetValue(0, -6.5, 0)
# ------------------------------------------------------------
# Create Boy's surface
# ------------------------------------------------------------
boy = vtk.vtkParametricBoy()
boySource = vtk.vtkParametricFunctionSource()
boySource.SetParametricFunction(boy)
boySource.SetScalarModeToModulus()
boyMapper = vtk.vtkPolyDataMapper()
boyMapper.SetInputConnection(boySource.GetOutputPort())
boyMapper.SetScalarRange(0, 2)
boyActor = vtk.vtkActor()
boyActor.SetMapper(boyMapper)
boyActor.SetPosition(8, -4, 0)
boyActor.SetScale(1.5, 1.5, 1.5)
boyTextMapper = vtk.vtkTextMapper()
boyTextMapper.SetInput("Boy")
boyTextMapper.GetTextProperty().SetJustificationToCentered()
boyTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
boyTextMapper.GetTextProperty().SetColor(1, 0, 0)
boyTextMapper.GetTextProperty().SetFontSize(14)
boyTextActor = vtk.vtkActor2D()
boyTextActor.SetMapper(boyTextMapper)
boyTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
boyTextActor.GetPositionCoordinate().SetValue(8, -6.5, 0)
# ------------------------------------------------------------
# Create a cross cap
# ------------------------------------------------------------
crossCap = vtk.vtkParametricCrossCap()
crossCapSource = vtk.vtkParametricFunctionSource()
crossCapSource.SetParametricFunction(crossCap)
crossCapSource.SetScalarModeToY()
crossCapMapper = vtk.vtkPolyDataMapper()
crossCapMapper.SetInputConnection(crossCapSource.GetOutputPort())
crossCapActor = vtk.vtkActor()
crossCapActor.SetMapper(crossCapMapper)
crossCapActor.RotateX(65)
crossCapActor.SetPosition(16, -4, 0)
crossCapActor.SetScale(1.5, 1.5, 1.5)
crossCapTextMapper = vtk.vtkTextMapper()
crossCapTextMapper.SetInput("Cross.Cap")
crossCapTextMapper.GetTextProperty().SetJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetColor(1, 0, 0)
crossCapTextMapper.GetTextProperty().SetFontSize(14)
crossCapTextActor = vtk.vtkActor2D()
crossCapTextActor.SetMapper(crossCapTextMapper)
crossCapTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
crossCapTextActor.GetPositionCoordinate().SetValue(16, -6.5, 0)
# ------------------------------------------------------------
# Create Dini's surface
# ------------------------------------------------------------
dini = vtk.vtkParametricDini()
diniSource = vtk.vtkParametricFunctionSource()
diniSource.SetScalarModeToDistance()
diniSource.SetParametricFunction(dini)
diniMapper = vtk.vtkPolyDataMapper()
diniMapper.SetInputConnection(diniSource.GetOutputPort())
diniActor = vtk.vtkActor()
diniActor.SetMapper(diniMapper)
diniActor.RotateX(-90)
diniActor.SetPosition(24, -3, 0)
diniActor.SetScale(1.5, 1.5, 0.5)
diniTextMapper = vtk.vtkTextMapper()
diniTextMapper.SetInput("Dini")
diniTextMapper.GetTextProperty().SetJustificationToCentered()
diniTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
diniTextMapper.GetTextProperty().SetColor(1, 0, 0)
diniTextMapper.GetTextProperty().SetFontSize(14)
diniTextActor = vtk.vtkActor2D()
diniTextActor.SetMapper(diniTextMapper)
diniTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
diniTextActor.GetPositionCoordinate().SetValue(24, -6.5, 0)
# ------------------------------------------------------------
# Create Enneper's surface
# ------------------------------------------------------------
enneper = vtk.vtkParametricEnneper()
enneperSource = vtk.vtkParametricFunctionSource()
enneperSource.SetParametricFunction(enneper)
enneperSource.SetScalarModeToQuadrant()
enneperMapper = vtk.vtkPolyDataMapper()
enneperMapper.SetInputConnection(enneperSource.GetOutputPort())
enneperMapper.SetScalarRange(1, 4)
enneperActor = vtk.vtkActor()
enneperActor.SetMapper(enneperMapper)
enneperActor.SetPosition(0, -12, 0)
enneperActor.SetScale(0.25, 0.25, 0.25)
enneperTextMapper = vtk.vtkTextMapper()
enneperTextMapper.SetInput("Enneper")
enneperTextMapper.GetTextProperty().SetJustificationToCentered()
enneperTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
enneperTextMapper.GetTextProperty().SetColor(1, 0, 0)
enneperTextMapper.GetTextProperty().SetFontSize(14)
enneperTextActor = vtk.vtkActor2D()
enneperTextActor.SetMapper(enneperTextMapper)
enneperTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
enneperTextActor.GetPositionCoordinate().SetValue(0, -14.5, 0)
# ------------------------------------------------------------
# Create an ellipsoidal surface
# ------------------------------------------------------------
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(1)
ellipsoid.SetYRadius(0.75)
ellipsoid.SetZRadius(0.5)
ellipsoidSource = vtk.vtkParametricFunctionSource()
ellipsoidSource.SetParametricFunction(ellipsoid)
ellipsoidSource.SetScalarModeToZ()
ellipsoidMapper = vtk.vtkPolyDataMapper()
ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort())
ellipsoidMapper.SetScalarRange(-0.5, 0.5)
ellipsoidActor = vtk.vtkActor()
ellipsoidActor.SetMapper(ellipsoidMapper)
ellipsoidActor.SetPosition(8, -12, 0)
ellipsoidActor.SetScale(1.5, 1.5, 1.5)
ellipsoidTextMapper = vtk.vtkTextMapper()
ellipsoidTextMapper.SetInput("Ellipsoid")
ellipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
ellipsoidTextMapper.GetTextProperty().SetFontSize(14)
ellipsoidTextActor = vtk.vtkActor2D()
ellipsoidTextActor.SetMapper(ellipsoidTextMapper)
ellipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
ellipsoidTextActor.GetPositionCoordinate().SetValue(8, -14.5, 0)
# ------------------------------------------------------------
# Create an surface with random hills on it.
# Note that for testing, we will disable the
# random generation of the surfaces. This is
# because random number generators do not
# return the same result on different operating
# systems.
# ------------------------------------------------------------
randomHills = vtk.vtkParametricRandomHills()
randomHills.AllowRandomGenerationOff()
randomHills.GenerateTheHills()
randomHillsSource = vtk.vtkParametricFunctionSource()
randomHillsSource.SetParametricFunction(randomHills)
randomHillsSource.GenerateTextureCoordinatesOn()
randomHillsMapper = vtk.vtkPolyDataMapper()
randomHillsMapper.SetInputConnection(randomHillsSource.GetOutputPort())
randomHillsActor = vtk.vtkActor()
randomHillsActor.SetMapper(randomHillsMapper)
randomHillsActor.SetPosition(16, -14, 0)
randomHillsActor.SetScale(0.2, 0.2, 0.2)
randomHillsActor.SetTexture(texture)
randomHillsTextMapper = vtk.vtkTextMapper()
randomHillsTextMapper.SetInput("Random.Hills")
randomHillsTextMapper.GetTextProperty().SetJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetColor(1, 0, 0)
randomHillsTextMapper.GetTextProperty().SetFontSize(14)
randomHillsTextActor = vtk.vtkActor2D()
randomHillsTextActor.SetMapper(randomHillsTextMapper)
randomHillsTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
randomHillsTextActor.GetPositionCoordinate().SetValue(16, -14.5, 0)
# ------------------------------------------------------------
# Create an Steiner's Roman Surface.
# ------------------------------------------------------------
roman = vtk.vtkParametricRoman()
roman.SetRadius(1.5)
romanSource = vtk.vtkParametricFunctionSource()
romanSource.SetParametricFunction(roman)
romanSource.SetScalarModeToX()
romanMapper = vtk.vtkPolyDataMapper()
romanMapper.SetInputConnection(romanSource.GetOutputPort())
romanActor = vtk.vtkActor()
romanActor.SetMapper(romanMapper)
romanActor.SetPosition(24, -12, 0)
romanTextMapper = vtk.vtkTextMapper()
romanTextMapper.SetInput("Roman")
romanTextMapper.GetTextProperty().SetJustificationToCentered()
romanTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
romanTextMapper.GetTextProperty().SetColor(1, 0, 0)
romanTextMapper.GetTextProperty().SetFontSize(14)
romanTextActor = vtk.vtkActor2D()
romanTextActor.SetMapper(romanTextMapper)
romanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
romanTextActor.GetPositionCoordinate().SetValue(24, -14.5, 0)
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and both Actors
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(torusActor)
ren.AddViewProp(kleinActor)
ren.AddViewProp(klein2Actor)
ren.AddViewProp(toroidActor)
ren.AddViewProp(superEllipsoidActor)
ren.AddViewProp(mobiusActor)
ren.AddViewProp(splineActor)
ren.AddViewProp(spline2Actor)
ren.AddViewProp(sconicActor)
ren.AddViewProp(boyActor)
ren.AddViewProp(crossCapActor)
ren.AddViewProp(diniActor)
ren.AddViewProp(enneperActor)
ren.AddViewProp(ellipsoidActor)
ren.AddViewProp(randomHillsActor)
ren.AddViewProp(romanActor)
#add text actors
ren.AddViewProp(torusTextActor)
ren.AddViewProp(kleinTextActor)
ren.AddViewProp(fig8KleinTextActor)
ren.AddViewProp(mobiusTextActor)
ren.AddViewProp(superToroidTextActor)
ren.AddViewProp(superEllipsoidTextActor)
ren.AddViewProp(splineTextActor)
ren.AddViewProp(spline2TextActor)
ren.AddViewProp(sconicTextActor)
ren.AddViewProp(boyTextActor)
ren.AddViewProp(crossCapTextActor)
ren.AddViewProp(diniTextActor)
ren.AddViewProp(enneperTextActor)
ren.AddViewProp(ellipsoidTextActor)
ren.AddViewProp(randomHillsTextActor)
ren.AddViewProp(romanTextActor)
ren.SetBackground(0.7, 0.8, 1)
renWin.SetSize(500, 500)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1.3)
iren.Initialize()
renWin.Render()
img_file = "TestParametricFunctions.png"
vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=35)
vtk.test.Testing.interact()
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.ren.SetBackground(0.2, 0.3, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
points = vtk.vtkPoints()
points.InsertPoint(0, 1, 0, 0)
points.InsertPoint(1, 2, 0, 0)
points.InsertPoint(2, 3, 1, 0)
points.InsertPoint(3, 4, 1, 0)
points.InsertPoint(4, 5, 0, 0)
points.InsertPoint(5, 6, 0, 0)
# Fit a spline to the points
spline = vtk.vtkParametricSpline()
spline.SetPoints(points)
functionSource = vtk.vtkParametricFunctionSource()
functionSource.SetParametricFunction(spline)
functionSource.SetUResolution(10 * points.GetNumberOfPoints())
functionSource.Update()
# Interpolate the scalars
interpolatedRadius = vtk.vtkTupleInterpolator()
interpolatedRadius.SetInterpolationTypeToLinear()
interpolatedRadius.SetNumberOfComponents(1)
#interpolatedRadius.AddTuple(0, [0.2,]) ### ??? Donesn't work for Python
#interpolatedRadius.AddTuple(1, (0.2,))
#interpolatedRadius.AddTuple(2, (0.2,))
#interpolatedRadius.AddTuple(3, (0.1,))
#interpolatedRadius.AddTuple(4, (0.1,))
#interpolatedRadius.AddTuple(5, (0.1,))
# Generate the radius scalars
tubeRadius = vtk.vtkDoubleArray()
n = functionSource.GetOutput().GetNumberOfPoints()
tubeRadius.SetNumberOfTuples(n)
tubeRadius.SetName("TubeRadius")
tMin = interpolatedRadius.GetMinimumT()
tMax = interpolatedRadius.GetMaximumT()
for i in range(n):
t = (tMax - tMin) / (n - 1) * i + tMin
r = 1.0
#interpolatedRadius.InterpolateTuple(t, r) ### ??? Donesn't work for Python
tubeRadius.SetTuple1(i, r)
# Add the scalars to the polydata
tubePolyData = functionSource.GetOutput()
tubePolyData.GetPointData().AddArray(tubeRadius)
tubePolyData.GetPointData().SetActiveScalars("TubeRadius")
# Create the tubes
tuber = vtk.vtkTubeFilter()
tuber.SetInput(tubePolyData)
tuber.SetNumberOfSides(20)
tuber.SetVaryRadiusToVaryRadiusByAbsoluteScalar()
# Setup actors and mappers
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInput(tubePolyData)
lineMapper.SetScalarRange(tubePolyData.GetScalarRange())
tubeMapper = vtk.vtkPolyDataMapper()
tubeMapper.SetInputConnection(tuber.GetOutputPort())
tubeMapper.SetScalarRange(tubePolyData.GetScalarRange())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
tubeActor = vtk.vtkActor()
tubeActor.SetMapper(tubeMapper)
self.ren.AddActor(tubeActor)
self.ren.AddActor(lineActor)
self.ren.ResetCamera()
self._initialized = False
# of the intersection)
t = vtk.mutable(0)
pos = [0.0, 0.0, 0.0]
pcoords = [0.0, 0.0, 0.0]
subId = vtk.mutable(0)
locator.IntersectWithLine(p1, p2, tolerance, t, pos, pcoords, subId)
# Add a slight offset in z
pos[2] += 0.01
# Add the x, y, z position of the intersection
points.InsertNextPoint(pos)
# Create a spline and add the points
spline = vtk.vtkParametricSpline()
spline.SetPoints(points)
functionSource = vtk.vtkParametricFunctionSource()
functionSource.SetUResolution(maxloop)
functionSource.SetParametricFunction(spline)
# Map the spline
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(functionSource.GetOutputPort())
# Define the line actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor([1.0, 0.0, 0.0])
actor.GetProperty().SetLineWidth(3)
# Visualize
renderer = vtk.vtkRenderer()
#$U = \sum_1^3 \lambda_i \mathbf{r}_i \outer \mathbf{r}_i$
U = np.zeros((3, 3), np.float64)
l = [lam1, lam2, lam3]
for j in xrange(3):
r = np.dot(Q, np.eye(3)[:, j])
U += np.outer(l[j] * r, r)
ellipFunc = vtk.vtkParametricSuperEllipsoid()
ellipFunc.SetXRadius(a)
ellipFunc.SetYRadius(b)
ellipFunc.SetZRadius(c)
ellipFunc.SetN1(N1)
ellipFunc.SetN2(N2)
ellip = vtk.vtkParametricFunctionSource()
ellip.SetParametricFunction(ellipFunc)
ellip.SetUResolution(50)
ellip.SetVResolution(30)
ellip.SetWResolution(30)
ellip.SetScalarModeToNone()
ellip.Update()
d = np.pi / 15 * lam1 * a
resample = vtk.vtkPolyDataPointSampler()
resample.SetInputData(ellip.GetOutput())
resample.SetDistance(d)
resample.Update()
delaunay = vtk.vtkDelaunay3D()
delaunay.SetInputData(resample.GetOutput())
from vtk_py import vtkOperations,vtkConditions,vtkIO;
import vtk;
destDir = "/Users/david/Downloads/3D_Models/vtk_basic/"
destFileName = "Union"
writerFactory = vtkIO.VTKPolyWriterFactory(destFormat="ply",destDir=destDir,destFileName=destFileName);
basicSources=(vtk.vtkSphereSource,vtk.vtkCubeSource,vtk.vtkConeSource,vtk.vtkCylinderSource,)
basicObjects=(vtk.vtkParametricTorus,vtk.vtkParametricBoy,vtk.vtkParametricConicSpiral,vtk.vtkParametricDini,vtk.vtkParametricEllipsoid,vtk.vtkParametricEnneper,vtk.vtkParametricFigure8Klein,vtk.vtkParametricKlein,vtk.vtkParametricMobius,vtk.vtkParametricRandomHills,vtk.vtkParametricSuperToroid,vtk.vtkParametricSuperEllipsoid,vtk.vtkParametricTorus);
cleanOp = vtkOperations.TransformOp(vtkOperations.BoostSizeOp(vtkOperations.Polygon2TriangleOp(vtkOperations.CleanUnusedOp())));
polyDatas = {};
for source in basicSources:
obj = source();
obj.Update();
cleanOp.data = obj.GetOutput()
polyDatas[obj.__class__.__name__] = cleanOp.perform();
for obj in basicObjects:
pre_build_obj = obj();
print("Building {}".format(pre_build_obj.__class__.__name__));
pre_build_obj2Poly = vtk.vtkParametricFunctionSource();
pre_build_obj2Poly.SetParametricFunction(pre_build_obj)
pre_build_obj2Poly.Update();
cleanOp.data = pre_build_obj2Poly.GetOutput()
polyDatas[pre_build_obj.__class__.__name__] = cleanOp.perform();
for name,poly in polyDatas.iteritems():
writerFactory.destFileName = name;
writerFactory.update();
writerFactory.getWriter(poly).Write();
def ParametricObjects(self):
parametricObjects = list()
parametricObjects.append(vtk.vtkParametricBoy())
parametricObjects.append(vtk.vtkParametricConicSpiral())
parametricObjects.append(vtk.vtkParametricCrossCap())
parametricObjects.append(vtk.vtkParametricDini())
parametricObjects.append(vtk.vtkParametricEllipsoid())
parametricObjects[-1].SetXRadius(0.5)
parametricObjects[-1].SetYRadius(2.0)
parametricObjects.append(vtk.vtkParametricEnneper())
parametricObjects.append(vtk.vtkParametricFigure8Klein())
parametricObjects.append(vtk.vtkParametricKlein())
parametricObjects.append(vtk.vtkParametricMobius())
parametricObjects[-1].SetRadius(2)
parametricObjects[-1].SetMinimumV(-0.5)
parametricObjects[-1].SetMaximumV(0.5)
parametricObjects.append(vtk.vtkParametricRandomHills())
parametricObjects[-1].AllowRandomGenerationOff()
parametricObjects.append(vtk.vtkParametricRoman())
parametricObjects.append(vtk.vtkParametricSuperEllipsoid())
parametricObjects[-1].SetN1(0.5)
parametricObjects[-1].SetN2(0.1)
parametricObjects.append(vtk.vtkParametricSuperToroid())
parametricObjects[-1].SetN1(0.2)
parametricObjects[-1].SetN2(3.0)
parametricObjects.append(vtk.vtkParametricTorus())
parametricObjects.append(vtk.vtkParametricSpline())
# Add some points to the parametric spline.
inputPoints = vtk.vtkPoints()
vtk.vtkMath.RandomSeed(8775070)
for i in range(10):
x = vtk.vtkMath.Random(0.0,1.0)
y = vtk.vtkMath.Random(0.0,1.0)
z = vtk.vtkMath.Random(0.0,1.0)
inputPoints.InsertNextPoint(x, y, z)
parametricObjects[-1].SetPoints(inputPoints)
# There are only 15 objects.
parametricFunctionSources = list()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
# Create a parametric function source, renderer, mapper
# and actor for each object.
for idx, item in enumerate(parametricObjects):
parametricFunctionSources.append(vtk.vtkParametricFunctionSource())
parametricFunctionSources[idx].SetParametricFunction(item)
parametricFunctionSources[idx].Update()
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(parametricFunctionSources[idx].GetOutputPort())
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(item.GetClassName())
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(100, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 4
for idx in range(len(parametricObjects)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 200
# 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(parametricObjects) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.2,0.3,0.4)
renderers[idx].ResetCamera()
renderers[idx].GetActiveCamera().Azimuth(30)
renderers[idx].GetActiveCamera().Elevation(-30)
renderers[idx].GetActiveCamera().Zoom(0.9)
renderers[idx].ResetCameraClippingRange()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def testParametricFunctions(self):
# ------------------------------------------------------------
# Get a texture
# ------------------------------------------------------------
textureReader = vtk.vtkJPEGReader()
textureReader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg")
texture = vtk.vtkTexture()
texture.SetInputConnection(textureReader.GetOutputPort())
# ------------------------------------------------------------
# For each parametric surface:
# 1) Create it
# 2) Assign mappers and actors
# 3) Position this object
# 5) Add a label
# ------------------------------------------------------------
# ------------------------------------------------------------
# Create a torus
# ------------------------------------------------------------
torus = vtk.vtkParametricTorus()
torusSource = vtk.vtkParametricFunctionSource()
torusSource.SetParametricFunction(torus)
torusSource.SetScalarModeToPhase()
torusMapper = vtk.vtkPolyDataMapper()
torusMapper.SetInputConnection(torusSource.GetOutputPort())
torusMapper.SetScalarRange(0, 360)
torusActor = vtk.vtkActor()
torusActor.SetMapper(torusMapper)
torusActor.SetPosition(0, 12, 0)
torusTextMapper = vtk.vtkTextMapper()
torusTextMapper.SetInput("Torus")
torusTextMapper.GetTextProperty().SetJustificationToCentered()
torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
torusTextMapper.GetTextProperty().SetColor(1, 0, 0)
torusTextMapper.GetTextProperty().SetFontSize(14)
torusTextActor = vtk.vtkActor2D()
torusTextActor.SetMapper(torusTextMapper)
torusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
torusTextActor.GetPositionCoordinate().SetValue(0, 9.5, 0)
# ------------------------------------------------------------
# Create a klein bottle
# ------------------------------------------------------------
klein = vtk.vtkParametricKlein()
kleinSource = vtk.vtkParametricFunctionSource()
kleinSource.SetParametricFunction(klein)
kleinSource.SetScalarModeToU0V0()
kleinMapper = vtk.vtkPolyDataMapper()
kleinMapper.SetInputConnection(kleinSource.GetOutputPort())
kleinMapper.SetScalarRange(0, 3)
kleinActor = vtk.vtkActor()
kleinActor.SetMapper(kleinMapper)
kleinActor.SetPosition(8, 10.5, 0)
kleinTextMapper = vtk.vtkTextMapper()
kleinTextMapper.SetInput("Klein")
kleinTextMapper.GetTextProperty().SetJustificationToCentered()
kleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
kleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
kleinTextMapper.GetTextProperty().SetFontSize(14)
kleinTextActor = vtk.vtkActor2D()
kleinTextActor.SetMapper(kleinTextMapper)
kleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
kleinTextActor.GetPositionCoordinate().SetValue(8, 9.5, 0)
# ------------------------------------------------------------
# Create a Figure-8 Klein
# ------------------------------------------------------------
klein2 = vtk.vtkParametricFigure8Klein()
klein2Source = vtk.vtkParametricFunctionSource()
klein2Source.SetParametricFunction(klein2)
klein2Source.GenerateTextureCoordinatesOn()
klein2Mapper = vtk.vtkPolyDataMapper()
klein2Mapper.SetInputConnection(klein2Source.GetOutputPort())
klein2Mapper.SetScalarRange(0, 3)
klein2Actor = vtk.vtkActor()
klein2Actor.SetMapper(klein2Mapper)
klein2Actor.SetPosition(16, 12, 0)
klein2Actor.SetTexture(texture)
fig8KleinTextMapper = vtk.vtkTextMapper()
fig8KleinTextMapper.SetInput("Fig-8.Klein")
fig8KleinTextMapper.GetTextProperty().SetJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
fig8KleinTextMapper.GetTextProperty().SetColor(1, 0, 0)
fig8KleinTextMapper.GetTextProperty().SetFontSize(14)
fig8KleinTextActor = vtk.vtkActor2D()
fig8KleinTextActor.SetMapper(fig8KleinTextMapper)
fig8KleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
fig8KleinTextActor.GetPositionCoordinate().SetValue(16, 9.5, 0)
# ------------------------------------------------------------
# Create a mobius strip
# ------------------------------------------------------------
mobius = vtk.vtkParametricMobius()
mobiusSource = vtk.vtkParametricFunctionSource()
mobiusSource.SetParametricFunction(mobius)
mobiusSource.GenerateTextureCoordinatesOn()
mobiusMapper = vtk.vtkPolyDataMapper()
mobiusMapper.SetInputConnection(mobiusSource.GetOutputPort())
mobiusActor = vtk.vtkActor()
mobiusActor.SetMapper(mobiusMapper)
mobiusActor.RotateX(45)
mobiusActor.SetPosition(24, 12, 0)
mobiusActor.SetTexture(texture)
mobiusTextMapper = vtk.vtkTextMapper()
mobiusTextMapper.SetInput("Mobius")
mobiusTextMapper.GetTextProperty().SetJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
mobiusTextMapper.GetTextProperty().SetColor(1, 0, 0)
mobiusTextMapper.GetTextProperty().SetFontSize(14)
mobiusTextActor = vtk.vtkActor2D()
mobiusTextActor.SetMapper(mobiusTextMapper)
mobiusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
mobiusTextActor.GetPositionCoordinate().SetValue(24, 9.5, 0)
# ------------------------------------------------------------
# Create a super toroid
# ------------------------------------------------------------
toroid = vtk.vtkParametricSuperToroid()
toroid.SetN1(2)
toroid.SetN2(3)
toroidSource = vtk.vtkParametricFunctionSource()
toroidSource.SetParametricFunction(toroid)
toroidSource.SetScalarModeToU()
toroidMapper = vtk.vtkPolyDataMapper()
toroidMapper.SetInputConnection(toroidSource.GetOutputPort())
toroidMapper.SetScalarRange(0, 6.28)
toroidActor = vtk.vtkActor()
toroidActor.SetMapper(toroidMapper)
toroidActor.SetPosition(0, 4, 0)
superToroidTextMapper = vtk.vtkTextMapper()
superToroidTextMapper.SetInput("Super.Toroid")
superToroidTextMapper.GetTextProperty().SetJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superToroidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superToroidTextMapper.GetTextProperty().SetFontSize(14)
superToroidTextActor = vtk.vtkActor2D()
superToroidTextActor.SetMapper(superToroidTextMapper)
superToroidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superToroidTextActor.GetPositionCoordinate().SetValue(0, 1.5, 0)
# ------------------------------------------------------------
# Create a super ellipsoid
# ------------------------------------------------------------
superEllipsoid = vtk.vtkParametricSuperEllipsoid()
superEllipsoid.SetXRadius(1.25)
superEllipsoid.SetYRadius(1.5)
superEllipsoid.SetZRadius(1.0)
superEllipsoid.SetN1(1.1)
superEllipsoid.SetN2(1.75)
superEllipsoidSource = vtk.vtkParametricFunctionSource()
superEllipsoidSource.SetParametricFunction(superEllipsoid)
superEllipsoidSource.SetScalarModeToV()
superEllipsoidMapper = vtk.vtkPolyDataMapper()
superEllipsoidMapper.SetInputConnection(superEllipsoidSource.GetOutputPort())
superEllipsoidMapper.SetScalarRange(0, 3.14)
superEllipsoidActor = vtk.vtkActor()
superEllipsoidActor.SetMapper(superEllipsoidMapper)
superEllipsoidActor.SetPosition(8, 4, 0)
superEllipsoidTextMapper = vtk.vtkTextMapper()
superEllipsoidTextMapper.SetInput("Super.Ellipsoid")
superEllipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
superEllipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
superEllipsoidTextMapper.GetTextProperty().SetFontSize(14)
superEllipsoidTextActor = vtk.vtkActor2D()
superEllipsoidTextActor.SetMapper(superEllipsoidTextMapper)
superEllipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
superEllipsoidTextActor.GetPositionCoordinate().SetValue(8, 1.5, 0)
# ------------------------------------------------------------
# Create an open 1D spline
# ------------------------------------------------------------
math = vtk.vtkMath()
inputPoints = vtk.vtkPoints()
for i in range(0, 10):
x = math.Random(-1, 1)
y = math.Random(-1, 1)
z = math.Random(-1, 1)
inputPoints.InsertPoint(i,x,y,z)
spline = vtk.vtkParametricSpline()
spline.SetPoints(inputPoints)
spline.ClosedOff()
splineSource = vtk.vtkParametricFunctionSource()
splineSource.SetParametricFunction(spline)
splineMapper = vtk.vtkPolyDataMapper()
splineMapper.SetInputConnection(splineSource.GetOutputPort())
splineActor = vtk.vtkActor()
splineActor.SetMapper(splineMapper)
splineActor.SetPosition(16, 4, 0)
splineActor.GetProperty().SetColor(0, 0, 0)
splineTextMapper = vtk.vtkTextMapper()
splineTextMapper.SetInput("Open.Spline")
splineTextMapper.GetTextProperty().SetJustificationToCentered()
splineTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
splineTextMapper.GetTextProperty().SetColor(1, 0, 0)
splineTextMapper.GetTextProperty().SetFontSize(14)
splineTextActor = vtk.vtkActor2D()
splineTextActor.SetMapper(splineTextMapper)
splineTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
splineTextActor.GetPositionCoordinate().SetValue(16, 1.5, 0)
# ------------------------------------------------------------
# Create a closed 1D spline
# ------------------------------------------------------------
spline2 = vtk.vtkParametricSpline()
spline2.SetPoints(inputPoints)
spline2.ClosedOn()
spline2Source = vtk.vtkParametricFunctionSource()
spline2Source.SetParametricFunction(spline2)
spline2Mapper = vtk.vtkPolyDataMapper()
spline2Mapper.SetInputConnection(spline2Source.GetOutputPort())
spline2Actor = vtk.vtkActor()
spline2Actor.SetMapper(spline2Mapper)
spline2Actor.SetPosition(24, 4, 0)
spline2Actor.GetProperty().SetColor(0, 0, 0)
spline2TextMapper = vtk.vtkTextMapper()
spline2TextMapper.SetInput("Closed.Spline")
spline2TextMapper.GetTextProperty().SetJustificationToCentered()
spline2TextMapper.GetTextProperty().SetVerticalJustificationToCentered()
spline2TextMapper.GetTextProperty().SetColor(1, 0, 0)
spline2TextMapper.GetTextProperty().SetFontSize(14)
spline2TextActor = vtk.vtkActor2D()
spline2TextActor.SetMapper(spline2TextMapper)
spline2TextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
spline2TextActor.GetPositionCoordinate().SetValue(24, 1.5, 0)
# ------------------------------------------------------------
# Create a spiral conic
# ------------------------------------------------------------
sconic = vtk.vtkParametricConicSpiral()
sconic.SetA(0.8)
sconic.SetB(2.5)
sconic.SetC(0.4)
sconicSource = vtk.vtkParametricFunctionSource()
sconicSource.SetParametricFunction(sconic)
sconicSource.SetScalarModeToDistance()
sconicMapper = vtk.vtkPolyDataMapper()
sconicMapper.SetInputConnection(sconicSource.GetOutputPort())
sconicActor = vtk.vtkActor()
sconicActor.SetMapper(sconicMapper)
sconicMapper.SetScalarRange(0, 9)
sconicActor.SetPosition(0, -4, 0)
sconicActor.SetScale(1.2, 1.2, 1.2)
sconicTextMapper = vtk.vtkTextMapper()
sconicTextMapper.SetInput("Spiral.Conic")
sconicTextMapper.GetTextProperty().SetJustificationToCentered()
sconicTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
sconicTextMapper.GetTextProperty().SetColor(1, 0, 0)
sconicTextMapper.GetTextProperty().SetFontSize(14)
sconicTextActor = vtk.vtkActor2D()
sconicTextActor.SetMapper(sconicTextMapper)
sconicTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
sconicTextActor.GetPositionCoordinate().SetValue(0, -6.5, 0)
# ------------------------------------------------------------
# Create Boy's surface
# ------------------------------------------------------------
boy = vtk.vtkParametricBoy()
boySource = vtk.vtkParametricFunctionSource()
boySource.SetParametricFunction(boy)
boySource.SetScalarModeToModulus()
boyMapper = vtk.vtkPolyDataMapper()
boyMapper.SetInputConnection(boySource.GetOutputPort())
boyMapper.SetScalarRange(0, 2)
boyActor = vtk.vtkActor()
boyActor.SetMapper(boyMapper)
boyActor.SetPosition(8, -4, 0)
boyActor.SetScale(1.5, 1.5, 1.5)
boyTextMapper = vtk.vtkTextMapper()
boyTextMapper.SetInput("Boy")
boyTextMapper.GetTextProperty().SetJustificationToCentered()
boyTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
boyTextMapper.GetTextProperty().SetColor(1, 0, 0)
boyTextMapper.GetTextProperty().SetFontSize(14)
boyTextActor = vtk.vtkActor2D()
boyTextActor.SetMapper(boyTextMapper)
boyTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
boyTextActor.GetPositionCoordinate().SetValue(8, -6.5, 0)
# ------------------------------------------------------------
# Create a cross cap
# ------------------------------------------------------------
crossCap = vtk.vtkParametricCrossCap()
crossCapSource = vtk.vtkParametricFunctionSource()
crossCapSource.SetParametricFunction(crossCap)
crossCapSource.SetScalarModeToY()
crossCapMapper = vtk.vtkPolyDataMapper()
crossCapMapper.SetInputConnection(crossCapSource.GetOutputPort())
crossCapActor = vtk.vtkActor()
crossCapActor.SetMapper(crossCapMapper)
crossCapActor.RotateX(65)
crossCapActor.SetPosition(16, -4, 0)
crossCapActor.SetScale(1.5, 1.5, 1.5)
crossCapTextMapper = vtk.vtkTextMapper()
crossCapTextMapper.SetInput("Cross.Cap")
crossCapTextMapper.GetTextProperty().SetJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
crossCapTextMapper.GetTextProperty().SetColor(1, 0, 0)
crossCapTextMapper.GetTextProperty().SetFontSize(14)
crossCapTextActor = vtk.vtkActor2D()
crossCapTextActor.SetMapper(crossCapTextMapper)
crossCapTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
crossCapTextActor.GetPositionCoordinate().SetValue(16, -6.5, 0)
# ------------------------------------------------------------
# Create Dini's surface
# ------------------------------------------------------------
dini = vtk.vtkParametricDini()
diniSource = vtk.vtkParametricFunctionSource()
diniSource.SetScalarModeToDistance()
diniSource.SetParametricFunction(dini)
diniMapper = vtk.vtkPolyDataMapper()
diniMapper.SetInputConnection(diniSource.GetOutputPort())
diniActor = vtk.vtkActor()
diniActor.SetMapper(diniMapper)
diniActor.RotateX(-90)
diniActor.SetPosition(24, -3, 0)
diniActor.SetScale(1.5, 1.5, 0.5)
diniTextMapper = vtk.vtkTextMapper()
diniTextMapper.SetInput("Dini")
diniTextMapper.GetTextProperty().SetJustificationToCentered()
diniTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
diniTextMapper.GetTextProperty().SetColor(1, 0, 0)
diniTextMapper.GetTextProperty().SetFontSize(14)
diniTextActor = vtk.vtkActor2D()
diniTextActor.SetMapper(diniTextMapper)
diniTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
diniTextActor.GetPositionCoordinate().SetValue(24, -6.5, 0)
# ------------------------------------------------------------
# Create Enneper's surface
# ------------------------------------------------------------
enneper = vtk.vtkParametricEnneper()
enneperSource = vtk.vtkParametricFunctionSource()
enneperSource.SetParametricFunction(enneper)
enneperSource.SetScalarModeToQuadrant()
enneperMapper = vtk.vtkPolyDataMapper()
enneperMapper.SetInputConnection(enneperSource.GetOutputPort())
enneperMapper.SetScalarRange(1, 4)
enneperActor = vtk.vtkActor()
enneperActor.SetMapper(enneperMapper)
enneperActor.SetPosition(0, -12, 0)
enneperActor.SetScale(0.25, 0.25, 0.25)
enneperTextMapper = vtk.vtkTextMapper()
enneperTextMapper.SetInput("Enneper")
enneperTextMapper.GetTextProperty().SetJustificationToCentered()
enneperTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
enneperTextMapper.GetTextProperty().SetColor(1, 0, 0)
enneperTextMapper.GetTextProperty().SetFontSize(14)
enneperTextActor = vtk.vtkActor2D()
enneperTextActor.SetMapper(enneperTextMapper)
enneperTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
enneperTextActor.GetPositionCoordinate().SetValue(0, -14.5, 0)
# ------------------------------------------------------------
# Create an ellipsoidal surface
# ------------------------------------------------------------
ellipsoid = vtk.vtkParametricEllipsoid()
ellipsoid.SetXRadius(1)
ellipsoid.SetYRadius(0.75)
ellipsoid.SetZRadius(0.5)
ellipsoidSource = vtk.vtkParametricFunctionSource()
ellipsoidSource.SetParametricFunction(ellipsoid)
ellipsoidSource.SetScalarModeToZ()
ellipsoidMapper = vtk.vtkPolyDataMapper()
ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort())
ellipsoidMapper.SetScalarRange(-0.5, 0.5)
ellipsoidActor = vtk.vtkActor()
ellipsoidActor.SetMapper(ellipsoidMapper)
ellipsoidActor.SetPosition(8, -12, 0)
ellipsoidActor.SetScale(1.5, 1.5, 1.5)
ellipsoidTextMapper = vtk.vtkTextMapper()
ellipsoidTextMapper.SetInput("Ellipsoid")
ellipsoidTextMapper.GetTextProperty().SetJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
ellipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0)
ellipsoidTextMapper.GetTextProperty().SetFontSize(14)
ellipsoidTextActor = vtk.vtkActor2D()
ellipsoidTextActor.SetMapper(ellipsoidTextMapper)
ellipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
ellipsoidTextActor.GetPositionCoordinate().SetValue(8, -14.5, 0)
# ------------------------------------------------------------
# Create an surface with random hills on it.
# Note that for testing, we will disable the
# random generation of the surfaces. This is
# because random number generators do not
# return the same result on different operating
# systems.
# ------------------------------------------------------------
randomHills = vtk.vtkParametricRandomHills()
randomHills.AllowRandomGenerationOff()
randomHills.GenerateTheHills()
randomHillsSource = vtk.vtkParametricFunctionSource()
randomHillsSource.SetParametricFunction(randomHills)
randomHillsSource.GenerateTextureCoordinatesOn()
randomHillsMapper = vtk.vtkPolyDataMapper()
randomHillsMapper.SetInputConnection(randomHillsSource.GetOutputPort())
randomHillsActor = vtk.vtkActor()
randomHillsActor.SetMapper(randomHillsMapper)
randomHillsActor.SetPosition(16, -14, 0)
randomHillsActor.SetScale(0.2, 0.2, 0.2)
randomHillsActor.SetTexture(texture)
randomHillsTextMapper = vtk.vtkTextMapper()
randomHillsTextMapper.SetInput("Random.Hills")
randomHillsTextMapper.GetTextProperty().SetJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
randomHillsTextMapper.GetTextProperty().SetColor(1, 0, 0)
randomHillsTextMapper.GetTextProperty().SetFontSize(14)
randomHillsTextActor = vtk.vtkActor2D()
randomHillsTextActor.SetMapper(randomHillsTextMapper)
randomHillsTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
randomHillsTextActor.GetPositionCoordinate().SetValue(16, -14.5, 0)
# ------------------------------------------------------------
# Create an Steiner's Roman Surface.
# ------------------------------------------------------------
roman = vtk.vtkParametricRoman()
roman.SetRadius(1.5)
romanSource = vtk.vtkParametricFunctionSource()
romanSource.SetParametricFunction(roman)
romanSource.SetScalarModeToX()
romanMapper = vtk.vtkPolyDataMapper()
romanMapper.SetInputConnection(romanSource.GetOutputPort())
romanActor = vtk.vtkActor()
romanActor.SetMapper(romanMapper)
romanActor.SetPosition(24, -12, 0)
romanTextMapper = vtk.vtkTextMapper()
romanTextMapper.SetInput("Roman")
romanTextMapper.GetTextProperty().SetJustificationToCentered()
romanTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
romanTextMapper.GetTextProperty().SetColor(1, 0, 0)
romanTextMapper.GetTextProperty().SetFontSize(14)
romanTextActor = vtk.vtkActor2D()
romanTextActor.SetMapper(romanTextMapper)
romanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
romanTextActor.GetPositionCoordinate().SetValue(24, -14.5, 0)
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and both Actors
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(torusActor)
ren.AddViewProp(kleinActor)
ren.AddViewProp(klein2Actor)
ren.AddViewProp(toroidActor)
ren.AddViewProp(superEllipsoidActor)
ren.AddViewProp(mobiusActor)
ren.AddViewProp(splineActor)
ren.AddViewProp(spline2Actor)
ren.AddViewProp(sconicActor)
ren.AddViewProp(boyActor)
ren.AddViewProp(crossCapActor)
ren.AddViewProp(diniActor)
ren.AddViewProp(enneperActor)
ren.AddViewProp(ellipsoidActor)
ren.AddViewProp(randomHillsActor)
ren.AddViewProp(romanActor)
#add text actors
ren.AddViewProp(torusTextActor)
ren.AddViewProp(kleinTextActor)
ren.AddViewProp(fig8KleinTextActor)
ren.AddViewProp(mobiusTextActor)
ren.AddViewProp(superToroidTextActor)
ren.AddViewProp(superEllipsoidTextActor)
ren.AddViewProp(splineTextActor)
ren.AddViewProp(spline2TextActor)
ren.AddViewProp(sconicTextActor)
ren.AddViewProp(boyTextActor)
ren.AddViewProp(crossCapTextActor)
ren.AddViewProp(diniTextActor)
ren.AddViewProp(enneperTextActor)
ren.AddViewProp(ellipsoidTextActor)
ren.AddViewProp(randomHillsTextActor)
ren.AddViewProp(romanTextActor)
ren.SetBackground(0.7, 0.8, 1)
renWin.SetSize(500, 500)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1.3)
iren.Initialize()
renWin.Render()
#iren.Start()
img_file = "TestParametricFunctions.png"
vtk.test.Testing.compareImage(iren.GetRenderWindow(),vtk.test.Testing.getAbsImagePath(img_file),threshold=25)
vtk.test.Testing.interact()
def setWidgetView(self, widget):
super(CenterLineView, self).setWidgetView(widget)
point_array = self.parent.getData().pointSet
point_data = npy.array(point_array.getData('Centerline'))
if point_data is None or not point_data.shape[0]:
return
#self.spacing = [1, 1, 1]
self.spacing = self.parent.getData().getResolution().tolist()
self.spacing = [float(x) / self.spacing[-1] for x in self.spacing]
point_data[:, :2] *= self.spacing[:2]
self.renderer = vtk.vtkRenderer()
self.render_window = widget.GetRenderWindow()
self.render_window.AddRenderer(self.renderer)
self.window_interactor = vtk.vtkRenderWindowInteractor()
self.render_window.SetInteractor(self.window_interactor)
self.center = []
self.center_mapper = []
self.center_actor = []
self.points = []
self.para_spline = []
self.spline_source = []
for cnt in range(3):
self.center.append(vtk.vtkPolyData())
self.center_mapper.append(vtk.vtkPolyDataMapper())
self.center_actor.append(vtk.vtkActor())
self.points.append(vtk.vtkPoints())
self.para_spline.append(vtk.vtkParametricSpline())
self.spline_source.append(vtk.vtkParametricFunctionSource())
point = point_data[npy.where(npy.round(point_data[:, -1]) == cnt)]
point = point[point[:, 2].argsort(), :]
count = point.shape[0]
if not count:
continue
self.points[cnt].SetNumberOfPoints(count)
for i in range(count):
self.points[cnt].SetPoint(i, point[i, 0], point[i, 1], point[i, 2])
self.para_spline[cnt].SetPoints(self.points[cnt])
self.spline_source[cnt].SetParametricFunction(self.para_spline[cnt])
numberOfOutputPoints = count * 10
self.spline_source[cnt].SetUResolution(numberOfOutputPoints)
self.center_mapper[cnt].SetInput(self.spline_source[cnt].GetOutput())
self.center_mapper[cnt].ScalarVisibilityOff()
self.center_actor[cnt].SetMapper(self.center_mapper[cnt])
color = [0, 0, 0]
color[cnt] = 1
self.center_actor[cnt].GetProperty().SetColor(color[0], color[1], color[2])
self.renderer.AddViewProp(self.center_actor[cnt])
bound = npy.array(self.parent.getData().getData().shape)[::-1] * self.spacing
outline_source = vtk.vtkOutlineSource()
outline_source.SetBounds(0, bound[0], 0, bound[1], 0, bound[2])
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outline_source.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(mapOutline)
outlineActor.GetProperty().SetColor(1, 1, 1)
self.renderer.AddViewProp(outlineActor)
self.renderer.ResetCamera()
point = self.renderer.GetActiveCamera().GetFocalPoint()
dis = self.renderer.GetActiveCamera().GetDistance()
self.renderer.GetActiveCamera().SetViewUp(0, 0, 1)
self.renderer.GetActiveCamera().SetPosition(point[0], point[1] - dis, point[2])
self.renderer.ResetCameraClippingRange()
self.render_window.Render()
# Manually set to trackball style
self.window_interactor.SetKeyCode('t')
self.window_interactor.CharEvent()
self.window_interactor.GetInteractorStyle().AddObserver("KeyPressEvent", self.KeyPressCallback)
self.window_interactor.GetInteractorStyle().AddObserver("CharEvent", self.KeyPressCallback)
def testMoreParametricFunctions(self):
# ------------------------------------------------------------
# For each parametric surface:
# 1) Create it
# 2) Assign mappers and actors
# 3) Position the object
# 5) Add a label
# ------------------------------------------------------------
# ------------------------------------------------------------
# Create Kuen's Surface.
# ------------------------------------------------------------
kuen = vtk.vtkParametricKuen()
kuenSource = vtk.vtkParametricFunctionSource()
kuenSource.SetParametricFunction(kuen)
kuenSource.SetScalarModeToU()
kuenMapper = vtk.vtkPolyDataMapper()
kuenMapper.SetInputConnection(kuenSource.GetOutputPort())
kuenActor = vtk.vtkActor()
kuenActor.SetMapper(kuenMapper)
kuenActor.SetPosition(0, -19, 0)
kuenActor.RotateX(90)
kuenTextMapper = vtk.vtkTextMapper()
kuenTextMapper.SetInput("Kuen")
kuenTextMapper.GetTextProperty().SetJustificationToCentered()
kuenTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
kuenTextMapper.GetTextProperty().SetColor(1, 0, 0)
kuenTextMapper.GetTextProperty().SetFontSize(14)
kuenTextActor = vtk.vtkActor2D()
kuenTextActor.SetMapper(kuenTextMapper)
kuenTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
kuenTextActor.GetPositionCoordinate().SetValue(0, -22.5, 0)
# ------------------------------------------------------------
# Create a Pseudosphere
# ------------------------------------------------------------
pseudo = vtk.vtkParametricPseudosphere()
pseudo.SetMinimumU(-3)
pseudo.SetMaximumU(3)
pseudoSource = vtk.vtkParametricFunctionSource()
pseudoSource.SetParametricFunction(pseudo)
pseudoSource.SetScalarModeToY()
pseudoMapper = vtk.vtkPolyDataMapper()
pseudoMapper.SetInputConnection(pseudoSource.GetOutputPort())
pseudoActor = vtk.vtkActor()
pseudoActor.SetMapper(pseudoMapper)
pseudoActor.SetPosition(8, -19, 0)
pseudoActor.RotateX(90)
pseudoTextMapper = vtk.vtkTextMapper()
pseudoTextMapper.SetInput("Pseudosphere")
pseudoTextMapper.GetTextProperty().SetJustificationToCentered()
pseudoTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
pseudoTextMapper.GetTextProperty().SetColor(1, 0, 0)
pseudoTextMapper.GetTextProperty().SetFontSize(14)
pseudoTextActor = vtk.vtkActor2D()
pseudoTextActor.SetMapper(pseudoTextMapper)
pseudoTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
pseudoTextActor.GetPositionCoordinate().SetValue(8, -22.5, 0)
# ------------------------------------------------------------
# Create a Bohemian Dome
# ------------------------------------------------------------
bdome = vtk.vtkParametricBohemianDome()
bdomeSource = vtk.vtkParametricFunctionSource()
bdomeSource.SetParametricFunction(bdome)
bdomeSource.SetScalarModeToU()
bdomeMapper = vtk.vtkPolyDataMapper()
bdomeMapper.SetInputConnection(bdomeSource.GetOutputPort())
bdomeActor = vtk.vtkActor()
bdomeActor.SetMapper(bdomeMapper)
bdomeActor.SetPosition(16, -19, 0)
bdomeActor.RotateY(90)
bdomeTextMapper = vtk.vtkTextMapper()
bdomeTextMapper.SetInput("Bohemian Dome")
bdomeTextMapper.GetTextProperty().SetJustificationToCentered()
bdomeTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
bdomeTextMapper.GetTextProperty().SetColor(1, 0, 0)
bdomeTextMapper.GetTextProperty().SetFontSize(14)
bdomeTextActor = vtk.vtkActor2D()
bdomeTextActor.SetMapper(bdomeTextMapper)
bdomeTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
bdomeTextActor.GetPositionCoordinate().SetValue(16, -22.5, 0)
# ------------------------------------------------------------
# Create Henneberg's Minimal Surface
# ------------------------------------------------------------
hberg = vtk.vtkParametricHenneberg()
hberg.SetMinimumU(-0.3)
hberg.SetMaximumU(0.3)
hbergSource = vtk.vtkParametricFunctionSource()
hbergSource.SetParametricFunction(hberg)
hbergSource.SetScalarModeToV()
hbergMapper = vtk.vtkPolyDataMapper()
hbergMapper.SetInputConnection(hbergSource.GetOutputPort())
hbergActor = vtk.vtkActor()
hbergActor.SetMapper(hbergMapper)
hbergActor.SetPosition(24, -19, 0)
hbergActor.RotateY(90)
hbergTextMapper = vtk.vtkTextMapper()
hbergTextMapper.SetInput("Henneberg")
hbergTextMapper.GetTextProperty().SetJustificationToCentered()
hbergTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
hbergTextMapper.GetTextProperty().SetColor(1, 0, 0)
hbergTextMapper.GetTextProperty().SetFontSize(14)
hbergTextActor = vtk.vtkActor2D()
hbergTextActor.SetMapper(hbergTextMapper)
hbergTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
hbergTextActor.GetPositionCoordinate().SetValue(24, -22.5, 0)
# ------------------------------------------------------------
# Create Catalan's Minimal Surface
# ------------------------------------------------------------
catalan = vtk.vtkParametricCatalanMinimal()
catalan.SetMinimumU(-2.0 * math.pi)
catalan.SetMaximumU(2.0 * math.pi)
catalanSource = vtk.vtkParametricFunctionSource()
catalanSource.SetParametricFunction(catalan)
catalanSource.SetScalarModeToV()
catalanMapper = vtk.vtkPolyDataMapper()
catalanMapper.SetInputConnection(catalanSource.GetOutputPort())
catalanActor = vtk.vtkActor()
catalanActor.SetMapper(catalanMapper)
catalanActor.SetPosition(0, -27, 0)
catalanActor.SetScale(0.5, 0.5, 0.5)
catalanTextMapper = vtk.vtkTextMapper()
catalanTextMapper.SetInput("Catalan")
catalanTextMapper.GetTextProperty().SetJustificationToCentered()
catalanTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
catalanTextMapper.GetTextProperty().SetColor(1, 0, 0)
catalanTextMapper.GetTextProperty().SetFontSize(14)
catalanTextActor = vtk.vtkActor2D()
catalanTextActor.SetMapper(catalanTextMapper)
catalanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
catalanTextActor.GetPositionCoordinate().SetValue(0, -30.5, 0)
# ------------------------------------------------------------
# Create Bour's Minimal Surface
# ------------------------------------------------------------
bour = vtk.vtkParametricBour()
bourSource = vtk.vtkParametricFunctionSource()
bourSource.SetParametricFunction(bour)
bourSource.SetScalarModeToU()
bourMapper = vtk.vtkPolyDataMapper()
bourMapper.SetInputConnection(bourSource.GetOutputPort())
bourActor = vtk.vtkActor()
bourActor.SetMapper(bourMapper)
bourActor.SetPosition(8, -27, 0)
bourTextMapper = vtk.vtkTextMapper()
bourTextMapper.SetInput("Bour")
bourTextMapper.GetTextProperty().SetJustificationToCentered()
bourTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
bourTextMapper.GetTextProperty().SetColor(1, 0, 0)
bourTextMapper.GetTextProperty().SetFontSize(14)
bourTextActor = vtk.vtkActor2D()
bourTextActor.SetMapper(bourTextMapper)
bourTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
bourTextActor.GetPositionCoordinate().SetValue(8, -30.5, 0)
# ------------------------------------------------------------
# Create Plucker's Conoid Surface
# ------------------------------------------------------------
plucker = vtk.vtkParametricPluckerConoid()
pluckerSource = vtk.vtkParametricFunctionSource()
pluckerSource.SetParametricFunction(plucker)
pluckerSource.SetScalarModeToZ()
pluckerMapper = vtk.vtkPolyDataMapper()
pluckerMapper.SetInputConnection(pluckerSource.GetOutputPort())
pluckerActor = vtk.vtkActor()
pluckerActor.SetMapper(pluckerMapper)
pluckerActor.SetPosition(16, -27, 0)
pluckerTextMapper = vtk.vtkTextMapper()
pluckerTextMapper.SetInput("Plucker")
pluckerTextMapper.GetTextProperty().SetJustificationToCentered()
pluckerTextMapper.GetTextProperty().SetVerticalJustificationToCentered()
pluckerTextMapper.GetTextProperty().SetColor(1, 0, 0)
pluckerTextMapper.GetTextProperty().SetFontSize(14)
pluckerTextActor = vtk.vtkActor2D()
pluckerTextActor.SetMapper(pluckerTextMapper)
pluckerTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld()
pluckerTextActor.GetPositionCoordinate().SetValue(16, -30.5, 0)
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and all vtkActors
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(kuenActor)
ren.AddViewProp(pseudoActor)
ren.AddViewProp(bdomeActor)
ren.AddViewProp(hbergActor)
ren.AddViewProp(catalanActor)
ren.AddViewProp(bourActor)
ren.AddViewProp(pluckerActor)
# add text actors
ren.AddViewProp(kuenTextActor)
ren.AddViewProp(pseudoTextActor)
ren.AddViewProp(bdomeTextActor)
ren.AddViewProp(hbergTextActor)
ren.AddViewProp(catalanTextActor)
ren.AddViewProp(bourTextActor)
ren.AddViewProp(pluckerTextActor)
ren.SetBackground(0.9, 0.9, 0.9)
renWin.SetSize(500, 500)
ren.ResetCamera()
iren.Initialize()
renWin.Render()
img_file = "TestMoreParametricFunctions.png"
vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10)
vtk.test.Testing.interact()
