def subdivide_surface(self):
if self.divide_algorith == "Butterfly":
self.vtk_sd = vtk.vtkButterflySubdivisionFilter()
else:
self.vtk_sd = vtk.vtkInterpolatingSubdivisionFilter()
self.vtk_sd.SetNumberOfSubdivisions(self.subdivide)
self.vtk_sd.SetInputConnection(self.vtk_surface.GetOutputPort())
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkButterflySubdivisionFilter(), 'Processing.',
('vtkPolyData',), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def Subdivide(self, nsub, subfilter='linear'):
"""
Increase the number of triangles in a single, connected triangular
mesh.
Uses one of the following vtk subdivision filters to subdivide a mesh.
vtkButterflySubdivisionFilter
vtkLoopSubdivisionFilter
vtkLinearSubdivisionFilter
Linear subdivision results in the fastest mesh subdivision, but it
does not smooth mesh edges, but rather splits each triangle into 4
smaller triangles.
Butterfly and loop subdivision perform smoothing when dividing, and may
introduce artifacts into the mesh when dividing.
Subdivision filter appears to fail for multiple part meshes. Should
be one single mesh.
Parameters
----------
nsub : int
Number of subdivisions. Each subdivision creates 4 new triangles,
so the number of resulting triangles is nface*4**nsub where nface
is the current number of faces.
subfilter : string, optional
Can be one of the following: 'butterfly', 'loop', 'linear'
Returns
-------
mesh : Polydata object
vtkInterface polydata object.
Examples
--------
>>> from vtkInterface import examples
>>> import vtkInterface
>>> mesh = vtkInterface.LoadMesh(examples.planefile)
>>> submesh = mesh.Subdivide(1, 'loop')
"""
subfilter = subfilter.lower()
if subfilter == 'linear':
sfilter = vtk.vtkLinearSubdivisionFilter()
elif subfilter == 'butterfly':
sfilter = vtk.vtkButterflySubdivisionFilter()
elif subfilter == 'loop':
sfilter = vtk.vtkLoopSubdivisionFilter()
else:
raise Exception(
"Subdivision filter must be one of the following: " +
"'butterfly', 'loop', or 'linear'")
# Subdivide
sfilter.SetNumberOfSubdivisions(nsub)
sfilter.SetInputData(self)
sfilter.Update()
return PolyData(sfilter.GetOutput())
def smooth_mesh(dmc, iterations=20):
inputPoly = vtk.vtkPolyData()
inputPoly.ShallowCopy(dmc.GetOutput())
cleanPolyData = vtk.vtkCleanPolyData()
cleanPolyData.SetInputData(inputPoly)
cleanPolyData.Update()
smooth_butterfly = vtk.vtkButterflySubdivisionFilter()
smooth_butterfly.SetNumberOfSubdivisions(0)
smooth_butterfly.SetInputConnection(cleanPolyData.GetOutputPort())
smooth_butterfly.Update()
upsampledInputPoly = vtk.vtkPolyData()
upsampledInputPoly.DeepCopy(smooth_butterfly.GetOutput())
decimate = vtk.vtkDecimatePro()
decimate.SetInputData(upsampledInputPoly)
decimate.SetTargetReduction(0.0)
decimate.PreserveTopologyOn()
decimate.Update()
smoother = vtk.vtkSmoothPolyDataFilter()
smoother.SetInputConnection(decimate.GetOutputPort())
smoother.SetNumberOfIterations(iterations) #
smoother.SetRelaxationFactor(0.1)
smoother.FeatureEdgeSmoothingOff()
smoother.BoundarySmoothingOn()
smoother.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(smoother.GetOutputPort())
normals.FlipNormalsOn()
return normals
def subdivide(actor, N=1, method=0, legend=None):
'''
Increase the number of points in actor surface
N = number of subdivisions
method = 0, Loop
method = 1, Linear
method = 2, Adaptive
method = 3, Butterfly
'''
triangles = vtk.vtkTriangleFilter()
setInput(triangles, polydata(actor))
triangles.Update()
originalMesh = triangles.GetOutput()
if method == 0: sdf = vtk.vtkLoopSubdivisionFilter()
elif method == 1: sdf = vtk.vtkLinearSubdivisionFilter()
elif method == 2: sdf = vtk.vtkAdaptiveSubdivisionFilter()
elif method == 3: sdf = vtk.vtkButterflySubdivisionFilter()
else:
colors.printc('Error in subdivide: unknown method.', 'r')
exit(1)
if method != 2: sdf.SetNumberOfSubdivisions(N)
setInput(sdf, originalMesh)
sdf.Update()
out = sdf.GetOutput()
if legend is None and hasattr(actor, 'legend'): legend = actor.legend
sactor = makeActor(out, legend=legend)
sactor.GetProperty().SetOpacity(actor.GetProperty().GetOpacity())
sactor.GetProperty().SetColor(actor.GetProperty().GetColor())
sactor.GetProperty().SetRepresentation(
actor.GetProperty().GetRepresentation())
return sactor
def surface(vertices, faces=None, colors=None, smooth=None, subdivision=3):
points = vtk.vtkPoints()
points.SetData(numpy_support.numpy_to_vtk(vertices))
triangle_poly_data = vtk.vtkPolyData()
triangle_poly_data.SetPoints(points)
if colors is not None:
triangle_poly_data.GetPointData().SetScalars(
numpy_support.numpy_to_vtk(colors))
if faces is None:
tri = Delaunay(vertices[:, [0, 1]])
faces = np.array(tri.simplices, dtype='i8')
if faces.shape[1] == 3:
triangles = np.empty((faces.shape[0], 4), dtype=np.int64)
triangles[:, -3:] = faces
triangles[:, 0] = 3
else:
triangles = faces
if not triangles.flags['C_CONTIGUOUS'] or triangles.dtype != 'int64':
triangles = np.ascontiguousarray(triangles, 'int64')
cells = vtk.vtkCellArray()
cells.SetCells(triangles.shape[0],
numpy_support.numpy_to_vtkIdTypeArray(triangles, deep=True))
triangle_poly_data.SetPolys(cells)
clean_poly_data = vtk.vtkCleanPolyData()
clean_poly_data.SetInputData(triangle_poly_data)
mapper = vtk.vtkPolyDataMapper()
surface_actor = vtk.vtkActor()
if smooth is None:
mapper.SetInputData(triangle_poly_data)
surface_actor.SetMapper(mapper)
elif smooth == "loop":
smooth_loop = vtk.vtkLoopSubdivisionFilter()
smooth_loop.SetNumberOfSubdivisions(subdivision)
smooth_loop.SetInputConnection(clean_poly_data.GetOutputPort())
mapper.SetInputConnection(smooth_loop.GetOutputPort())
surface_actor.SetMapper(mapper)
elif smooth == "butterfly":
smooth_butterfly = vtk.vtkButterflySubdivisionFilter()
smooth_butterfly.SetNumberOfSubdivisions(subdivision)
smooth_butterfly.SetInputConnection(clean_poly_data.GetOutputPort())
mapper.SetInputConnection(smooth_butterfly.GetOutputPort())
surface_actor.SetMapper(mapper)
return surface_actor
def subdivision(poly, num, option='linear'):
if option == 'linear':
divide = vtk.vtkLinearSubdivisionFilter()
elif option == 'loop':
divide = vtk.vtkLoopSubdivisionFilter()
elif option == 'butterfly':
divide = vtk.vtkButterflySubdivisionFilter()
else:
print("subdivision option: linear, loop or butterfly")
raise
divide.SetInputData(poly)
divide.SetNumberOfSubdivisions(num)
divide.Update()
return divide.GetOutput()
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.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
originalMesh = sphereSource.GetOutput()
numberOfViewports = 3
self.vtkWidget.GetRenderWindow().SetSize(200 * numberOfViewports, 200)
numberOfSubdivisions = 2
for i in range(numberOfViewports):
if i == 0:
subdivisionFilter = vtk.vtkLinearSubdivisionFilter()
elif i == 1:
subdivisionFilter = vtk.vtkLoopSubdivisionFilter()
else:
subdivisionFilter = vtk.vtkButterflySubdivisionFilter()
subdivisionFilter.SetNumberOfSubdivisions(numberOfSubdivisions)
subdivisionFilter.SetInputConnection(
originalMesh.GetProducerPort())
subdivisionFilter.Update()
renderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(renderer)
renderer.SetViewport(
float(i) / numberOfViewports, 0, (i + 1.0) / numberOfViewports,
1)
# Create a mapper and actor
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(subdivisionFilter.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.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.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
sphereSource = vtk.vtkSphereSource()
sphereSource.Update()
originalMesh = sphereSource.GetOutput()
numberOfViewports = 3
self.vtkWidget.GetRenderWindow().SetSize(200*numberOfViewports, 200)
numberOfSubdivisions = 2
for i in range(numberOfViewports):
if i == 0:
subdivisionFilter = vtk.vtkLinearSubdivisionFilter()
elif i == 1:
subdivisionFilter = vtk.vtkLoopSubdivisionFilter()
else:
subdivisionFilter = vtk.vtkButterflySubdivisionFilter()
subdivisionFilter.SetNumberOfSubdivisions(numberOfSubdivisions)
subdivisionFilter.SetInputConnection(originalMesh.GetProducerPort())
subdivisionFilter.Update()
renderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(renderer)
renderer.SetViewport(float(i)/numberOfViewports, 0, (i+1.0)/numberOfViewports, 1)
# Create a mapper and actor
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(subdivisionFilter.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
self._initialized = False
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
subdivisionFilter = None
if self.Method == 'linear':
subdivisionFilter = vtk.vtkLinearSubdivisionFilter()
elif self.Method == 'butterfly':
subdivisionFilter = vtk.vtkButterflySubdivisionFilter()
elif self.Method == 'loop':
subdivisionFilter = vtk.vtkLoopSubdivisionFilter()
else:
self.PrintError('Error: Unsupported subdivision method.')
subdivisionFilter.SetInputData(self.Surface)
subdivisionFilter.SetNumberOfSubdivisions(self.NumberOfSubdivisions)
subdivisionFilter.Update()
self.Surface = subdivisionFilter.GetOutput()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
subdivisionFilter = None
if self.Method == 'linear':
subdivisionFilter = vtk.vtkLinearSubdivisionFilter()
elif self.Method == 'butterfly':
subdivisionFilter = vtk.vtkButterflySubdivisionFilter()
elif self.Method == 'loop':
subdivisionFilter = vtk.vtkLoopSubdivisionFilter()
else:
self.PrintError('Error: Unsupported subdivision method.')
subdivisionFilter.SetInputData(self.Surface)
subdivisionFilter.SetNumberOfSubdivisions(self.NumberOfSubdivisions)
subdivisionFilter.Update()
self.Surface = subdivisionFilter.GetOutput()
def mesh_subdivision(self, num_subdivisions, method='loop'):
if method == 'loop':
subdivision_reader = vtk.vtkLoopSubdivisionFilter()
elif method == 'butterfly':
subdivision_reader = vtk.vtkButterflySubdivisionFilter()
else:
if self.warning:
print('Not a valid subdivision method')
subdivision_reader.SetInputData(self.vtkPolyData)
subdivision_reader.SetNumberOfSubdivisions(num_subdivisions)
subdivision_reader.Update()
self.vtkPolyData = subdivision_reader.GetOutput()
self.get_mesh_data_from_vtkPolyData()
if self.warning:
print(
'Warning! self.cell_attributes are reset and need to be updated!'
)
self.cell_attributes = dict() #reset
self.point_attributes = dict() #reset
# Add the geometry and topology to the polydata trianglePolyData.SetPoints(points) trianglePolyData.GetPointData().SetScalars(colors) trianglePolyData.SetPolys(triangles) # Clean the polydata so that the edges are shared ! cleanPolyData = vtk.vtkCleanPolyData() cleanPolyData.SetInputData(trianglePolyData) # Use a filter to smooth the data (will add triangles and smooth) # Use two different filters to show the difference smooth_loop = vtk.vtkLoopSubdivisionFilter() smooth_loop.SetNumberOfSubdivisions(3) smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort()) smooth_butterfly = vtk.vtkButterflySubdivisionFilter() smooth_butterfly.SetNumberOfSubdivisions(3) smooth_butterfly.SetInputConnection(cleanPolyData.GetOutputPort()) # Create a mapper and actor for initial dataset mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(trianglePolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a mapper and actor for smoothed dataset (vtkLoopSubdivisionFilter) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth_loop.GetOutputPort()) actor_loop = vtk.vtkActor() actor_loop.SetMapper(mapper) actor_loop.SetPosition(32, 0, 0)
af4.AddInputConnection(af3.GetOutputPort()) af4.AddInputConnection(tf6.GetOutputPort()) # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) clean = vtk.vtkCleanPolyData() clean.SetTolerance(.001) clean.SetInputData(model) clean.SetInputConnection(af2.GetOutputPort()) clean.SetInputConnection(af3.GetOutputPort()) clean.SetInputConnection(af4.GetOutputPort()) subdivide = vtk.vtkButterflySubdivisionFilter() subdivide.SetInputConnection(clean.GetOutputPort()) subdivide.SetNumberOfSubdivisions(3) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(subdivide.GetOutputPort()) surface = vtk.vtkActor() surface.SetMapper(mapper) fe = vtk.vtkFeatureEdges() fe.SetInputConnection(subdivide.GetOutputPort()) fe.SetFeatureAngle(100) feStripper = vtk.vtkStripper() feStripper.SetInputConnection(fe.GetOutputPort()) feTubes = vtk.vtkTubeFilter() feTubes.SetInputConnection(feStripper.GetOutputPort()) feTubes.SetRadius(.1) feMapper = vtk.vtkPolyDataMapper()
def main():
nc = vtk.vtkNamedColors()
# Make a 32 x 32 grid
size = 32
rn = vtk.vtkMinimalStandardRandomSequence()
rn.SetSeed(1)
# Define z values for the topography (random height)
topography = numpy.zeros([size, size])
for i in range(size):
for j in range(size):
topography[i][j] = rn.GetRangeValue(0, 5)
rn.Next()
# Define points, triangles and colors
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
points = vtk.vtkPoints()
triangles = vtk.vtkCellArray()
# Build the meshgrid manually
count = 0
for i in range(size - 1):
for j in range(size - 1):
z1 = topography[i][j]
z2 = topography[i][j + 1]
z3 = topography[i + 1][j]
# Triangle 1
points.InsertNextPoint(i, j, z1)
points.InsertNextPoint(i, (j + 1), z2)
points.InsertNextPoint((i + 1), j, z3)
triangle = vtk.vtkTriangle()
triangle.GetPointIds().SetId(0, count)
triangle.GetPointIds().SetId(1, count + 1)
triangle.GetPointIds().SetId(2, count + 2)
triangles.InsertNextCell(triangle)
z1 = topography[i][j + 1]
z2 = topography[i + 1][j + 1]
z3 = topography[i + 1][j]
# Triangle 2
points.InsertNextPoint(i, (j + 1), z1)
points.InsertNextPoint((i + 1), (j + 1), z2)
points.InsertNextPoint((i + 1), j, z3)
triangle = vtk.vtkTriangle()
triangle.GetPointIds().SetId(0, count + 3)
triangle.GetPointIds().SetId(1, count + 4)
triangle.GetPointIds().SetId(2, count + 5)
count += 6
triangles.InsertNextCell(triangle)
# Add some color
r = [int(i / float(size) * 255), int(j / float(size) * 255), 0]
colors.InsertNextTypedTuple(r)
colors.InsertNextTypedTuple(r)
colors.InsertNextTypedTuple(r)
colors.InsertNextTypedTuple(r)
colors.InsertNextTypedTuple(r)
colors.InsertNextTypedTuple(r)
# Create a polydata object
trianglePolyData = vtk.vtkPolyData()
# Add the geometry and topology to the polydata
trianglePolyData.SetPoints(points)
trianglePolyData.GetPointData().SetScalars(colors)
trianglePolyData.SetPolys(triangles)
# Clean the polydata so that the edges are shared !
cleanPolyData = vtk.vtkCleanPolyData()
cleanPolyData.SetInputData(trianglePolyData)
# Use a filter to smooth the data (will add triangles and smooth)
# Use two different filters to show the difference
smooth_loop = vtk.vtkLoopSubdivisionFilter()
smooth_loop.SetNumberOfSubdivisions(3)
smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort())
smooth_butterfly = vtk.vtkButterflySubdivisionFilter()
smooth_butterfly.SetNumberOfSubdivisions(3)
smooth_butterfly.SetInputConnection(cleanPolyData.GetOutputPort())
# Create a mapper and actor for initial dataset
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(trianglePolyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a mapper and actor for smoothed dataset (vtkLoopSubdivisionFilter)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smooth_loop.GetOutputPort())
actor_loop = vtk.vtkActor()
actor_loop.SetMapper(mapper)
actor_loop.SetPosition(32, 0, 0)
# Create a mapper and actor for smoothed dataset (vtkButterflySubdivisionFilter)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smooth_butterfly.GetOutputPort())
actor_butterfly = vtk.vtkActor()
actor_butterfly.SetMapper(mapper)
actor_butterfly.SetPosition(64, 0, 0)
# Visualise
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add actors and render
renderer.AddActor(actor)
renderer.AddActor(actor_loop)
renderer.AddActor(actor_butterfly)
renderer.SetBackground(nc.GetColor3d('AliceBlue'))
renderWindow.SetSize(900, 300)
renderWindow.Render()
renderer.GetActiveCamera().Elevation(-45)
renderer.GetActiveCamera().Zoom(3)
renderWindow.Render()
renderWindowInteractor.Start()
def updateModelFromMarkup(self, inputMarkup, outputModel):
"""
Update model to enclose all points in the input markup list
"""
# Delaunay triangulation is robust and creates nice smooth surfaces from a small number of points,
# however it can only generate convex surfaces robustly.
useDelaunay = True
# Create polydata point set from markup points
points = vtk.vtkPoints()
cellArray = vtk.vtkCellArray()
numberOfPoints = inputMarkup.GetNumberOfFiducials()
# Surface generation algorithms behave unpredictably when there are not enough points
# return if there are very few points
if useDelaunay:
if numberOfPoints < 3:
return
else:
if numberOfPoints < 10:
return
points.SetNumberOfPoints(numberOfPoints)
new_coord = [0.0, 0.0, 0.0]
for i in range(numberOfPoints):
inputMarkup.GetNthFiducialPosition(i, new_coord)
points.SetPoint(i, new_coord)
cellArray.InsertNextCell(numberOfPoints)
for i in range(numberOfPoints):
cellArray.InsertCellPoint(i)
pointPolyData = vtk.vtkPolyData()
pointPolyData.SetLines(cellArray)
pointPolyData.SetPoints(points)
# Create surface from point set
if useDelaunay:
delaunay = vtk.vtkDelaunay3D()
delaunay.SetInputData(pointPolyData)
surfaceFilter = vtk.vtkDataSetSurfaceFilter()
surfaceFilter.SetInputConnection(delaunay.GetOutputPort())
smoother = vtk.vtkButterflySubdivisionFilter()
smoother.SetInputConnection(surfaceFilter.GetOutputPort())
smoother.SetNumberOfSubdivisions(3)
smoother.Update()
outputModel.SetPolyDataConnection(smoother.GetOutputPort())
else:
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputData(pointPolyData)
surf.SetNeighborhoodSize(20)
surf.SetSampleSpacing(
80
) # lower value follows the small details more closely but more dense pointset is needed as input
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOff()
reverse.ReverseNormalsOff()
outputModel.SetPolyDataConnection(reverse.GetOutputPort())
# Create default model display node if does not exist yet
if not outputModel.GetDisplayNode():
modelDisplayNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLModelDisplayNode")
# Get color of edited segment
segmentationNode = self.scriptedEffect.parameterSetNode(
).GetSegmentationNode()
segmentID = self.scriptedEffect.parameterSetNode(
).GetSelectedSegmentID()
r, g, b = segmentationNode.GetSegmentation().GetSegment(
segmentID).GetColor()
modelDisplayNode.SetColor(r, g, b) # Edited segment color
modelDisplayNode.BackfaceCullingOff()
modelDisplayNode.SliceIntersectionVisibilityOn()
modelDisplayNode.SetSliceIntersectionThickness(2)
modelDisplayNode.SetOpacity(0.3) # Between 0-1, 1 being opaque
slicer.mrmlScene.AddNode(modelDisplayNode)
outputModel.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
outputModel.GetDisplayNode().SliceIntersectionVisibilityOn()
outputModel.Modified()
def vtk_mesh_subdivision():
"""Subdivide a mesh into more triangles
The subdivisions are increasing the faces by 4^# subdivisions
"""
# get the polydata for a mesh
v, f = wavefront.ellipsoid_mesh(1, 2, 3, density=20)
polydata = wavefront.meshtopolydata(v, f)
# subdivide using appropriate filter
smooth_loop = vtk.vtkLoopSubdivisionFilter()
smooth_loop.SetNumberOfSubdivisions(1) # can define the number of subdivisions
smooth_loop.SetInputData(polydata)
smooth_loop.Update()
poly_loop = vtk.vtkPolyData()
poly_loop.ShallowCopy(smooth_loop.GetOutput())
smooth_butterfly = vtk.vtkButterflySubdivisionFilter()
smooth_butterfly.SetNumberOfSubdivisions(3)
smooth_butterfly.SetInputData(polydata)
smooth_butterfly.Update()
poly_butterfly = vtk.vtkPolyData()
poly_butterfly.ShallowCopy(smooth_butterfly.GetOutput())
# Create a mapper and actor for initial dataset
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(polydata)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create a mapper and actor for smoothed dataset (vtkLoopSubdivisionFilter)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smooth_loop.GetOutputPort())
actor_loop = vtk.vtkActor()
actor_loop.SetMapper(mapper)
actor_loop.SetPosition(3, 0, 0)
# Create a mapper and actor for smoothed dataset (vtkButterflySubdivisionFilter)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smooth_butterfly.GetOutputPort())
actor_butterfly = vtk.vtkActor()
actor_butterfly.SetMapper(mapper)
actor_butterfly.SetPosition(6, 0, 0)
# Visualise
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add actors and render
renderer.AddActor(actor)
renderer.AddActor(actor_loop)
renderer.AddActor(actor_butterfly)
renderer.SetBackground(1, 1, 1) # Background color white
renderWindow.SetSize(800, 800)
renderWindow.Render()
renderWindowInteractor.Start()
# output to a new v, f array
# convert polydata to numpy
v_loop, f_loop = wavefront.polydatatomesh(poly_loop)
v_butterfly, f_butterfly = wavefront.polydatatomesh(poly_butterfly)
print('Original #V : {} #F : {}'.format(v.shape[0], f.shape[0]))
print('Loop #V : {} #F : {}'.format(v_loop.shape[0], f_loop.shape[0]))
print('BFly #V : {} #F : {}'.format(v_butterfly.shape[0], f_butterfly.shape[0]))
# Add the geometry and topology to the polydata trianglePolyData.SetPoints(points) trianglePolyData.GetPointData().SetScalars(colors) trianglePolyData.SetPolys(triangles) # Clean the polydata so that the edges are shared ! cleanPolyData = vtk.vtkCleanPolyData() cleanPolyData.SetInputData(trianglePolyData) # Use a filter to smooth the data (will add triangles and smooth) # Use two different filters to show the difference smooth_loop = vtk.vtkLoopSubdivisionFilter() smooth_loop.SetNumberOfSubdivisions(3) smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort()) smooth_butterfly = vtk.vtkButterflySubdivisionFilter() smooth_butterfly.SetNumberOfSubdivisions(3) smooth_butterfly.SetInputConnection(cleanPolyData.GetOutputPort()) # Create a mapper and actor for initial dataset mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(trianglePolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a mapper and actor for smoothed dataset (vtkLoopSubdivisionFilter) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth_loop.GetOutputPort()) actor_loop = vtk.vtkActor() actor_loop.SetMapper(mapper) actor_loop.SetPosition(32, 0, 0)
def main():
def FlatInterpolation():
for actor in actors:
actor.GetProperty().SetInterpolationToFlat()
renWin.Render()
def GouraudInterpolation():
for actor in actors:
actor.GetProperty().SetInterpolationToGouraud()
renWin.Render()
sourceToUse, displayNormals, gouraudInterpolation, glyphPoints = GetProgramParameters(
)
if sourceToUse in Sources().sources:
src = Sources().sources[sourceToUse]
else:
print('The source {:s} is not available.'.format(sourceToUse))
print('Available sources are:\n',
', '.join(sorted(list(Sources().sources.keys()))))
return
src.Update()
# The size of the render window.
renWinXSize = 1200
renWinYSize = renWinXSize // 3
minRenWinDim = min(renWinXSize, renWinYSize)
# [xMin, xMax, yMin, yMax, zMin, zMax]
bounds = src.GetOutput().GetBounds()
# Use this to scale the normal glyph.
scaleFactor = min(map(lambda x, y: x - y, bounds[1::2], bounds[::2])) * 0.2
src.GetOutput().GetPointData().GetScalars().SetName("Elevation")
scalarRange = src.GetOutput().GetScalarRange()
butterfly = vtk.vtkButterflySubdivisionFilter()
butterfly.SetInputConnection(src.GetOutputPort())
butterfly.SetNumberOfSubdivisions(3)
butterfly.Update()
linear = vtk.vtkLinearSubdivisionFilter()
linear.SetInputConnection(src.GetOutputPort())
linear.SetNumberOfSubdivisions(3)
linear.Update()
lut = MakeLUT(scalarRange)
actors = list()
actors.append(MakeSurfaceActor(butterfly, scalarRange, lut))
actors.append(MakeSurfaceActor(linear, scalarRange, lut))
actors.append(MakeSurfaceActor(src, scalarRange, lut))
# Let's visualise the normals.
glyphActors = list()
if displayNormals:
glyphActors.append(
GlyphActor(butterfly, glyphPoints, scalarRange, scaleFactor, lut))
glyphActors.append(
GlyphActor(linear, glyphPoints, scalarRange, scaleFactor, lut))
glyphActors.append(
GlyphActor(src, glyphPoints, scalarRange, scaleFactor, lut))
labelActors = list()
labelActors.append(MakeLabel('Butterfly Subdivision', minRenWinDim))
labelActors.append(MakeLabel('Linear Subdivision', minRenWinDim))
labelActors.append(MakeLabel('Original', minRenWinDim))
ren = list()
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren.append(vtk.vtkRenderer())
ren[2].SetViewport(0, 0, 1.0 / 3.0, 1) # Original
ren[1].SetViewport(1.0 / 3.0, 0, 2.0 / 3.0, 1) # Linear
ren[0].SetViewport(2.0 / 3.0, 0, 1, 1) # Butterfly
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Orientation markers.
om = list()
# Make the imaging pipelines.
for i in range(0, len(ren)):
renWin.AddRenderer(ren[i])
ren[i].AddActor(actors[i])
ren[i].AddActor(labelActors[i])
ren[i].SetBackground(nc.GetColor3d('SlateGray'))
if displayNormals:
ren[i].AddActor(glyphActors[i])
om.append(MakeOrientationMarker(ren[i], iren))
if gouraudInterpolation:
GouraudInterpolation()
else:
FlatInterpolation()
renWin.SetSize(renWinXSize, renWinYSize)
renWin.Render()
# renWin.SetWindowName() needs to be called after renWin.Render()
renWin.SetWindowName('Point Data Subdivision Example')
iren.Initialize()
# WritePNG(iren.GetRenderWindow().GetRenderers().GetFirstRenderer(), "TestPointDataSubdivision.png")
iren.Start()
af4.AddInputConnection(af3.GetOutputPort()) af4.AddInputConnection(tf6.GetOutputPort()) # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) clean = vtk.vtkCleanPolyData() clean.SetTolerance(.001) clean.SetInputData(model) clean.SetInputConnection(af2.GetOutputPort()) clean.SetInputConnection(af3.GetOutputPort()) clean.SetInputConnection(af4.GetOutputPort()) subdivide = vtk.vtkButterflySubdivisionFilter() subdivide.SetInputConnection(clean.GetOutputPort()) subdivide.SetNumberOfSubdivisions(3) mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(subdivide.GetOutputPort()) surface = vtk.vtkActor() surface.SetMapper(mapper) fe = vtk.vtkFeatureEdges() fe.SetInputConnection(subdivide.GetOutputPort()) fe.SetFeatureAngle(100) feStripper = vtk.vtkStripper() feStripper.SetInputConnection(fe.GetOutputPort()) feTubes = vtk.vtkTubeFilter() feTubes.SetInputConnection(feStripper.GetOutputPort()) feTubes.SetRadius(.1) feMapper = vtk.vtkPolyDataMapper()
