def Execute(Surface, cl):
if Surface == None:
print 'Error: no Surface.'
sys.exit(0)
# Initialize
Clipper = vtk.vtkClipPolyData()
Clipper.SetInput(Surface)
Clipper.GenerateClippedOutputOn()
Clipper.SetInsideOut(0)
ClipFunction = vtk.vtkPlanes()
Clipper.SetClipFunction(ClipFunction)
Cutter = vtk.vtkCutter()
Cutter.SetInput(Surface)
Cutter.SetCutFunction(ClipFunction)
ClippedSurface = vtk.vtkPolyData()
CutLines = vtk.vtkPolyData()
ClipWidget = vtk.vtkBoxWidget()
ClipWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
ClipWidget.GetFaceProperty().SetOpacity(0.25)
Transform = vtk.vtkTransform()
ClipWidget.GetTransform(Transform)
for i in range(cl.GetNumberOfLines()):
# TODO: Implement thing here.
# Clean surface
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(Surface)
cleaner.Update()
Surface = cleaner.GetOutput()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(ClippedSurface)
cleaner.Update()
ClippedSurface = cleaner.GetOutput()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(CutLines)
cleaner.Update()
stripper = vtk.vtkStripper()
stripper.SetInput(cleaner.GetOutput())
stripper.Update()
CutLines = stripper.GetOutput()
if Surface.GetSource():
Surface.GetSource().UnRegisterAllOutputs()
if __name__=='__main__':
surface = read_command_line()
Execute()
def write_unstructured_grid(filename,
mesh,
cdata,
nEle,
EFs,
time,
verbose,
outline=False,
cut=[]):
writer = vtk.vtkXMLUnstructuredGridWriter()
## writer.SetDataModeToBinary()
writer.SetDataModeToAscii()
writer.SetFileName(filename + '.vtu')
extract = vtk.vtkExtractCells()
extract.SetInputData(mesh)
eleList = vtk.vtkIdList()
EF = cdata.GetArray('EF')
for k in range(nEle):
if (EFs[EF.GetValue(k)][0] < time and
EFs[EF.GetValue(k)][1] >= time) or (EFs[EF.GetValue(k)][0] == 0
and time == 0):
a = eleList.InsertNextId(k)
extract.SetCellList(eleList)
grid = extract.GetOutputPort()
if outline:
gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(grid)
cpd = vtk.vtkCleanPolyData()
cpd.SetInputConnection(gf.GetOutputPort())
cpd.Update()
af = vtk.vtkAppendFilter()
af.AddInputData(cpd.GetOutput())
grid = af.GetOutputPort()
elif len(cut):
plane = vtk.vtkPlane()
plane.SetOrigin(cut[0])
plane.SetNormal(cut[1])
cutter = vtk.vtkCutter()
cutter.SetInputConnection(grid)
cutter.SetCutFunction(plane)
cutter.Update()
cpd = vtk.vtkCleanPolyData()
cpd.SetInputConnection(cutter.GetOutputPort())
cpd.Update()
af = vtk.vtkAppendFilter()
af.AddInputData(cpd.GetOutput())
grid = af.GetOutputPort()
writer.SetFileName(filename + '_cut.vtu')
writer.SetInputConnection(grid)
writer.Write()
if not verbose:
print('%i elements written to %s' %
(eleList.GetNumberOfIds(), filename))
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# initialise any mixins we might have
NoConfigModuleMixin.__init__(self)
mm = self._module_manager
self._cleaner = vtk.vtkCleanPolyData()
self._tf = vtk.vtkTriangleFilter()
self._tf.SetInput(self._cleaner.GetOutput())
self._wspdf = vtk.vtkWindowedSincPolyDataFilter()
#self._wspdf.SetNumberOfIterations(50)
self._wspdf.SetInput(self._tf.GetOutput())
self._wspdf.SetProgressText('smoothing')
self._wspdf.SetProgressMethod(
lambda s=self, mm=mm: mm.vtk_progress_cb(s._wspdf))
self._cleaner2 = vtk.vtkCleanPolyData()
self._cleaner2.SetInput(self._wspdf.GetOutput())
self._curvatures = vtk.vtkCurvatures()
self._curvatures.SetCurvatureTypeToMean()
self._curvatures.SetInput(self._cleaner2.GetOutput())
self._tf.SetProgressText('triangulating')
self._tf.SetProgressMethod(
lambda s=self, mm=mm: mm.vtk_progress_cb(s._tf))
self._curvatures.SetProgressText('calculating curvatures')
self._curvatures.SetProgressMethod(
lambda s=self, mm=mm: mm.vtk_progress_cb(s._curvatures))
self._inputFilter = self._tf
self._inputPoints = None
self._inputPointsOID = None
self._giaGlenoid = None
self._outsidePoints = None
self._outputPolyDataARB = vtk.vtkPolyData()
self._outputPolyDataHM = vtk.vtkPolyData()
self._createViewFrame('Test Module View', {
'vtkTriangleFilter': self._tf,
'vtkCurvatures': self._curvatures
})
self._viewFrame.Show(True)
def get_topography_actor(x, y, topography, super_elevation, decimation,
smoothing=False):
topography = topography.T
topography *= super_elevation
points, triangles, colors = setup_topography(x, y, topography,
decimation=decimation)
# 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.SetInput(trianglePolyData)
# Use a filter to smooth the data (will add triangles and smooth)
# Use two different filters to show the difference
mapper = vtk.vtkPolyDataMapper()
if smoothing:
smooth_loop = vtk.vtkLoopSubdivisionFilter()
smooth_loop.SetNumberOfSubdivisions(2)
smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort())
mapper.SetInputConnection(smooth_loop.GetOutputPort())
else:
mapper.SetInput(trianglePolyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def ReadOBJFile(self, filename):
'''
@param filename: str
@rtype: None
'''
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
try:
reader.Update()
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInput(reader.GetOutput())
cleanFilter.ConvertLinesToPointsOn()
cleanFilter.ConvertPolysToLinesOn()
cleanFilter.ConvertStripsToPolysOn()
cleanFilter.PointMergingOn()
cleanFilter.Update()
surfaceFilter = vtk.vtkDataSetSurfaceFilter()
surfaceFilter.SetInput(cleanFilter.GetOutput())
surfaceFilter.Update()
self.setDataSet(surfaceFilter.GetOutput())
del cleanFilter
del surfaceFilter
except Exception, e:
# del reader
print e
raise IOError, "Could not read the OBJ file! "
def cleanMesh(mesh, connectivityFilter=False):
try:
t = time.clock()
connect = vtk.vtkPolyDataConnectivityFilter()
clean = vtk.vtkCleanPolyData()
if (connectivityFilter):
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
connect.SetInputData( mesh )
else:
connect.SetInput( mesh )
connect.SetExtractionModeToLargestRegion()
clean.SetInputConnection( connect.GetOutputPort() )
else:
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
clean.SetInputData( mesh )
else:
clean.SetInput( mesh )
clean.Update()
print ("Surface cleaned")
m2 = clean.GetOutput()
print " ", m2.GetNumberOfPolys(), "polygons"
elapsedTime(t)
clean = None
connect = None
return m2
except:
print "Surface cleaning failed"
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def VertFacetoPoly(new_pt, new_fc):
""" Creates a vtk polydata object given points and triangular faces """
# Convert points to vtkfloat object
points = np.vstack(new_pt)
vtkArray = VN.numpy_to_vtk(np.ascontiguousarray(points), deep=True)#, deep=True)
points = vtk.vtkPoints()
points.SetData(vtkArray)
# Convert faces to vtk cells object
ints = np.ones(len(new_fc), 'int')*3
cells = np.hstack((ints.reshape(-1, 1), np.vstack(new_fc)))
cells = np.ascontiguousarray(np.hstack(cells).astype('int64'))
vtkcells = vtk.vtkCellArray()
vtkcells.SetCells(cells.shape[0], VN.numpy_to_vtkIdTypeArray(cells, deep=True))
# Create polydata object
pdata = vtk.vtkPolyData()
pdata.SetPoints(points)
pdata.SetPolys(vtkcells)
# Remove duplicate verticies
clean = vtk.vtkCleanPolyData()
clean.ConvertPolysToLinesOff()
clean.ConvertLinesToPointsOff()
clean.ConvertStripsToPolysOff()
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
clean.SetInputData(pdata)
else:
clean.SetInput(pdata)
clean.Update()
return clean.GetOutput()
def generateSphereTemplate(self, model, spacingPercentage, scaleFactor):
[x1, x2, y1, y2, z1, z2] = model.GetPolyData().GetBounds()
lengthX = abs(x2 - x1)
lengthY = abs(y2 - y1)
lengthZ = abs(z2 - z1)
totalLength = lengthX + lengthY + lengthZ
sphereSamplingRate = int(math.pi / spacingPercentage)
sphereCenter = [((x2 - x1) / 2) + x1, ((y2 - y1) / 2) + y1,
((z2 - z1) / 2) + z1]
# Generate an ellipse equation
sphere = vtk.vtkSphereSource()
sphere.SetRadius(scaleFactor * totalLength / 6)
sphere.SetCenter(sphereCenter)
sphere.SetThetaResolution(sphereSamplingRate)
sphere.SetPhiResolution(sphereSamplingRate)
sphere.Update()
# Clean up semi-landmarks within tolerance
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetToleranceIsAbsolute(False)
cleanFilter.SetTolerance(spacingPercentage)
cleanFilter.SetInputData(sphere.GetOutput())
cleanFilter.Update()
return cleanFilter.GetOutput()
def curvature(actor, method=1, r=1, alpha=1, lut=None, legend=None):
'''
Build a copy of vtkActor that contains the color coded surface
curvature following four different ways to calculate it:
method = 0-gaussian, 1-mean, 2-max, 3-min
[**Example**](https://github.com/marcomusy/vtkplotter/blob/master/examples/tutorial.py)
'''
poly = actor.polydata()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputData(poly)
curve = vtk.vtkCurvatures()
curve.SetInputConnection(cleaner.GetOutputPort())
curve.SetCurvatureType(method)
curve.InvertMeanCurvatureOn()
curve.Update()
print('CurvatureType set to:', method)
if not lut:
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(256)
lut.SetHueRange(0.15, 1)
lut.SetSaturationRange(1, 1)
lut.SetValueRange(1, 1)
lut.SetAlphaRange(alpha, 1)
b = poly.GetBounds()
sc = max([b[1]-b[0], b[3]-b[2], b[5]-b[4]])
lut.SetRange(-0.01/sc*r, 0.01/sc*r)
cmapper = vtk.vtkPolyDataMapper()
cmapper.SetInputConnection(curve.GetOutputPort())
cmapper.SetLookupTable(lut)
cmapper.SetUseLookupTableScalarRange(1)
cactor = vtk.vtkActor()
cactor.SetMapper(cmapper)
return cactor
def SuperquadricSource():
"""
Make a torus as the source.
"""
source = vtk.vtkSuperquadricSource()
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
cleanerBounds = cleaner.GetOutput().GetBounds()
elev = vtk.vtkElevationFilter()
elev.SetInputConnection(cleaner.GetOutputPort())
elev.SetLowPoint(0, cleanerBounds[2], 0)
elev.SetHighPoint(0, cleanerBounds[3], 0)
elev.Update()
return elev
def create_sill(l):
pr1 = [(0, 0), (1.6666, 0), (1.6666, 1.875), (0, .91666)]
pr2 = [(.6666, 0), (1.6666, 0), (1.6666, 1.875), (.6666, 1.875)]
extr = extrude(pr1, l + 2 * .8333)
extr2 = extrude(pr2, .8333)
extr3 = extrude(pr2, .8333, l + .8333)
bf1 = vtkboolPython.vtkPolyDataBooleanFilter()
bf1.SetInputConnection(extr.GetOutputPort())
bf1.SetInputConnection(1, extr2.GetOutputPort())
bf2 = vtkboolPython.vtkPolyDataBooleanFilter()
bf2.SetInputConnection(bf1.GetOutputPort())
bf2.SetInputConnection(1, extr3.GetOutputPort())
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(bf2.GetOutputPort())
pn = vtk.vtkPolyDataNormals()
pn.SetInputConnection(clean.GetOutputPort())
pn.AutoOrientNormalsOn()
tr = vtk.vtkTransform()
tr.Translate(1.6666, 0, 0)
tr.RotateZ(180)
tr.RotateX(90)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(pn.GetOutputPort())
return tp
def runCleaningFast(self, projectedLM, sphere, spacingPercentage):
# Convert projected surface points to a VTK array for transform
p = [0, 0, 0]
targetPoints = vtk.vtkPoints()
for i in range(projectedLM.GetNumberOfFiducials()):
projectedLM.GetMarkupPoint(0, i, p)
targetPoints.InsertNextPoint(p)
templateData = sphere.GetPolyData()
templateData.SetPoints(targetPoints)
# Clean up semi-landmarks within radius
filter = vtk.vtkCleanPolyData()
filter.SetToleranceIsAbsolute(False)
filter.SetTolerance(spacingPercentage / 2)
filter.SetInputData(templateData)
filter.Update()
cleanPolyData = filter.GetOutput()
# Create a landmark node from the cleaned polyData
sphereSampleLMNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLMarkupsFiducialNode', "PseudoLandmarks")
sphereSampleLMNode.CreateDefaultDisplayNodes()
for i in range(cleanPolyData.GetNumberOfPoints()):
point = cleanPolyData.GetPoint(i)
sphereSampleLMNode.AddFiducialFromArray(point)
landmarkTypeSemi = True
self.setAllLandmarksType(sphereSampleLMNode, landmarkTypeSemi)
return sphereSampleLMNode
def create_sill3():
pr1 = [(0, 0), (1.75, 0), (1.75, 5. / 6 * 1.875), (0, 1.0833)]
pr2 = [(.75, 0), (1.75, 0), (1.75, 5. / 6 * 1.875), (.75, 5. / 6 * 1.875)]
extr = extrude(pr1, 22.7325 + 2 * .54125)
extr2 = extrude(pr2, .54125)
extr3 = extrude(pr2, .54125, 22.7325 + .54125)
bf1 = vtkboolPython.vtkPolyDataBooleanFilter()
bf1.SetInputConnection(extr.GetOutputPort())
bf1.SetInputConnection(1, extr2.GetOutputPort())
bf2 = vtkboolPython.vtkPolyDataBooleanFilter()
bf2.SetInputConnection(bf1.GetOutputPort())
bf2.SetInputConnection(1, extr3.GetOutputPort())
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(bf2.GetOutputPort())
pn = vtk.vtkPolyDataNormals()
pn.SetInputConnection(clean.GetOutputPort())
pn.AutoOrientNormalsOn()
tr = vtk.vtkTransform()
tr.Translate(1.75, 0, 0)
tr.RotateZ(180)
tr.RotateX(90)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(pn.GetOutputPort())
return tp
def downsample_surface(surface_file, reduction, output):
decimate = vtk.vtkDecimatePro()
clean = vtk.vtkCleanPolyData()
writer = vtk.vtkPolyDataWriter()
# load the surface
surface = load_vtk(surface_file)
# To guarantee a given level of reduction,
# the ivar PreserveTopology must be off; the ivar Splitting is on;
# the ivar BoundaryVertexDeletion is on; and the ivar MaximumError is set to VTK_DOUBLE_MAX
# reduce the number of vertices in the mesh
decimate.SetInputData(surface)
decimate.SetTargetReduction(reduction)
decimate.PreserveTopologyOff()
decimate.SplittingOn()
decimate.BoundaryVertexDeletionOn()
decimate.SetMaximumError(vtk.VTK_DOUBLE_MAX)
# remove unneeded vertices
clean.SetInputConnection(decimate.GetOutputPort())
clean.Update()
# save a copy of the downsampled mesh
writer.SetFileName(output)
writer.SetInputData(clean.GetOutput())
writer.Write()
def create_mesh(M,P,T):
n_naca_pts = 50
write_test_file(M,P,T,-5.,5.,nsections=5)
wing=create_wing('current_wing','output')
n_sections=len(wing)
n_section_pts = 2*n_naca_pts-1
# build mesh
vtk_model = vtk.vtkStructuredGrid()
vtk_model.SetDimensions(n_section_pts,n_sections,1)
# build points
vtk_points = vtk.vtkPoints()
for j in xrange(n_sections):
upper_pts = numpy.array([wing[j][1],wing[j][3]]).T
lower_pts = numpy.array([wing[j][2],wing[j][4]]).T
section_pts = numpy.concatenate((lower_pts[::-1],upper_pts[1:]))
for i in xrange(n_section_pts):
vtk_points.InsertNextPoint(section_pts[i,0],wing[j][0],section_pts[i,1])
# set points
vtk_model.SetPoints(vtk_points)
# convert to poly data
pdata_filter = vtk.vtkGeometryFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
pdata_filter.SetInput(vtk_model)
else:
pdata_filter.SetInputData(vtk_model)
pdata_filter.Update()
poly_data = pdata_filter.GetOutput()
# compute normals
norms = vtk.vtkPolyDataNormals()
if vtk.VTK_MAJOR_VERSION <= 5:
norms.SetInput(poly_data)
else:
norms.SetInputData(poly_data)
norms.ComputePointNormalsOff()
norms.ComputeCellNormalsOn()
norms.ConsistencyOn()
norms.Update()
# clean poly data
clean_poly = vtk.vtkCleanPolyData()
clean_poly.ToleranceIsAbsoluteOn()
clean_poly.SetAbsoluteTolerance(1.e-6)
if vtk.VTK_MAJOR_VERSION <= 5:
clean_poly.SetInput(norms.GetOutput())
else:
clean_poly.SetInputData(norms.GetOutput())
clean_poly.Update()
# write output mesh
writer = vtk.vtkXMLPolyDataWriter()
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(clean_poly.GetOutput())
else:
writer.SetInputData(clean_poly.GetOutput())
writer.SetFileName('output.vtp')
writer.Write()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputData(self.Surface)
triangleFilter.Update()
decimationFilter = vtk.vtkDecimatePro()
decimationFilter.SetInputConnection(triangleFilter.GetOutputPort())
decimationFilter.SetTargetReduction(self.TargetReduction)
decimationFilter.SetBoundaryVertexDeletion(self.BoundaryVertexDeletion)
decimationFilter.PreserveTopologyOn()
decimationFilter.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(decimationFilter.GetOutputPort())
cleaner.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(cleaner.GetOutputPort())
triangleFilter.Update()
self.Surface = triangleFilter.GetOutput()
def vtkReadVTKfile(self, filename):
""" Lecture d'un fichier vtk"""
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update() # Needed because of GetScalarRange
surface_filter = vtk.vtkDataSetSurfaceFilter()
surface_filter.SetInputConnection(reader.GetOutputPort())
self.meshNormals = vtk.vtkPolyDataNormals()
self.meshNormals.SetInputConnection(surface_filter.GetOutputPort())
self.meshNormals.SetFeatureAngle(60.0)
self.meshNormals.ComputeCellNormalsOn()
self.meshNormals.ComputePointNormalsOn()
self.meshNormals.ConsistencyOn()
self.meshNormals.AutoOrientNormalsOn()
self.meshNormals.Update()
# Sauvegarde des proprietes maillage GMSH pour calcul centerline
self.gmeshNode = vtk_to_np(surface_filter.GetOutput().GetPoints().GetData())
self.gmeshTable = vtk_to_np(surface_filter.GetOutput().GetPolys().GetData())
# 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
self.outputMesh = vtk.vtkCleanPolyData()
self.outputMesh.SetInputConnection(surface_filter.GetOutputPort())
self.outputMesh.SetTolerance(0.001)
def readMeshFile(filename, verbose=False):
"""Read mesh file.
The input format is determined by file name extension. Degenerate data gets
removed and polygons get split into triangles to support varios restrictive
output formats."""
informat = path.splitext(options.infilename)[1].strip('.')
# set reader based on filename extension
if informat == 'stl':
reader = vtk.vtkSTLReader()
elif informat == 'vtk':
reader = vtk.vtkPolyDataReader()
elif informat == 'obj':
reader = vtk.vtkMNIObjectReader()
#elif informat=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format' + informat)
reader.SetFileName(filename)
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(clean.GetOutputPort())
#triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work
if verbose:
print "read", filename
return triangles
def clean(inputModel, outputModel): """Merge coincident points, remove unused points (i.e. not used by any cell), treatment of degenerate cells. """ cleaner = vtk.vtkCleanPolyData() cleaner.SetInputData(inputModel.GetPolyData()) cleaner.Update() outputModel.SetAndObservePolyData(cleaner.GetOutput())
def vtkCreateIsoContour(self , config = 'MARCHINGCUBES'):
""" Fonction pour la creation de l'isocontour pour une valeur de seuillage"""
#-----------------------------------------
# Creation de l isocontour
#-----------------------------------------
if config == 'CONTOUR' :
self.aneurysmExtractor = vtk.vtkContourFilter()
if config == 'MARCHINGCUBES' :
self.aneurysmExtractor = vtk.vtkMarchingCubes()
self.aneurysmExtractor.SetInputConnection(self.vtkVolumBlur.GetOutputPort())
self.aneurysmExtractor.SetValue(0, self.valSeuil)
self.aneurysmExtractor.ComputeNormalsOn()
self.aneurysmTriangleFilter = vtk.vtkTriangleFilter()
self.aneurysmTriangleFilter.SetInputConnection(self.aneurysmExtractor.GetOutputPort())
self.aneurysmCleanFilter = vtk.vtkCleanPolyData()
self.aneurysmCleanFilter.SetInputConnection(self.aneurysmTriangleFilter.GetOutputPort())
self.aneurysmConnectFilter = vtk.vtkPolyDataConnectivityFilter()
self.aneurysmConnectFilter.SetExtractionModeToLargestRegion()
self.aneurysmConnectFilter.ScalarConnectivityOff()
self.aneurysmConnectFilter.SetInputConnection(self.aneurysmCleanFilter.GetOutputPort())
self.aneurysmNormals = vtk.vtkPolyDataNormals()
self.aneurysmNormals.SetInputConnection(self.aneurysmConnectFilter.GetOutputPort())
self.aneurysmNormals.SetFeatureAngle(60.0)
self.aneurysmNormals.ComputeCellNormalsOn()
self.aneurysmNormals.ComputePointNormalsOn()
self.aneurysmNormals.ConsistencyOn()
self.aneurysmNormals.AutoOrientNormalsOn()
self.aneurysmNormals.Update()
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 __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkCleanPolyData(), 'Processing.',
('vtkPolyData',), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def MakeTorus():
'''
Make a torus as the source.
:return: vtkPolyData with normal and scalar data.
'''
source = vtk.vtkSuperquadricSource();
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
return CalculateCurvatures(MakeElevations(cleaner.GetOutput()))
def isosurface(self, threshold=True):
"""Return a ``Mesh`` isosurface.
:param float,list threshold: value or list of values to draw the isosurface(s)
"""
if not self._data.GetPointData().GetScalars():
self.mapCellsToPoints()
scrange = self._data.GetPointData().GetScalars().GetRange()
cf = vtk.vtkContourFilter() #vtk.vtkContourGrid()
cf.SetInputData(self._data)
if utils.isSequence(threshold):
cf.SetNumberOfContours(len(threshold))
for i, t in enumerate(threshold):
cf.SetValue(i, t)
cf.Update()
else:
if threshold is True:
threshold = (2 * scrange[0] + scrange[1]) / 3.0
#print('automatic threshold set to ' + utils.precision(threshold, 3), end=' ')
#print('in [' + utils.precision(scrange[0], 3) + ', ' + utils.precision(scrange[1], 3)+']')
cf.SetValue(0, threshold)
cf.Update()
clp = vtk.vtkCleanPolyData()
clp.SetInputData(cf.GetOutput())
clp.Update()
msh = Mesh(clp.GetOutput(), c=None).phong()
msh._mapper.SetLookupTable(utils.ctf2lut(self))
return msh
def Execute(args):
reader = vmtkscripts.vmtkSurfaceReader()
reader.InputFileName = args.surface
reader.Execute()
Surface = reader.Surface
# estimates surface area to estimate the point density
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputData(Surface)
cleaner.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(cleaner.GetOutputPort())
triangleFilter.Update()
massProps = vtk.vtkMassProperties()
massProps.SetInputConnection(triangleFilter.GetOutputPort())
massProps.Update()
print(massProps.GetSurfaceArea())
area = massProps.GetSurfaceArea()
target_area = 3.0**0.5 / 4.0 * args.edge_length**2.0
print("target number of cells: {0}".format(
area / target_area)) # A_total = N*(area_equilateral_triangle)
print("target number of points: {0}".format(
area / target_area /
2.0)) #in the limit of equilateral triangles ratio ,Ncells/Npoints = 2
def update(self):
"""
"""
appendFilter = vtkAppendFilter()
appendFilter.AddInput(self.input_)
appendFilter.Update()
extractGrid = vtkExtractUnstructuredGrid()
extractGrid.SetInput(appendFilter.GetOutput())
extractGrid.SetExtent(self.extent[0], self.extent[1], self.extent[2],
self.extent[3], self.extent[4], self.extent[5])
geom = vtkGeometryFilter()
geom.SetInputConnection(extractGrid.GetOutputPort())
geom.Update()
clean = vtkCleanPolyData()
clean.PointMergingOn()
clean.SetTolerance(0.01)
clean.SetInput(geom.GetOutput())
clean.Update()
self.output_ = clean.GetOutput()
def combine_polydata(*args):
"""
References:
- https://www.vtk.org/Wiki/VTK/Examples/Python/Filtering/CombinePolyData
"""
# Append the two meshes
append_filter = vtk.vtkAppendPolyData()
#if vtk.VTK_MAJOR_VERSION <= 5:
# append_filter.AddInputConnection(vtk_polydata_1.GetProducerPort())
# append_filter.AddInputConnection(vtk_polydata_2.GetProducerPort())
#else:
# append_filter.AddInputData(vtk_polydata_1)
# append_filter.AddInputData(vtk_polydata_2)
for arg in args:
if isinstance(arg, vtk.vtkPolyData):
append_filter.AddInputData(arg)
if isinstance(arg, list):
for i in arg:
append_filter.AddInputData(i)
append_filter.Update()
clean_filter = vtk.vtkCleanPolyData()
clean_filter.SetInputConnection(append_filter.GetOutputPort())
clean_filter.Update()
return clean_filter
def CleanMesh(mesh, return_indices=False):
""" Cleans mesh and returns original indices """
if return_indices:
npoints = mesh.GetNumberOfPoints()
AddPointScalars(mesh, np.arange(npoints), 'cleanIDX', False)
clean = vtk.vtkCleanPolyData()
clean.ConvertPolysToLinesOff()
clean.ConvertLinesToPointsOff()
clean.ConvertStripsToPolysOff()
SetVTKInput(clean, mesh)
clean.Update()
cleanmesh = clean.GetOutput()
if return_indices:
origID = VN.vtk_to_numpy(cleanmesh.GetPointData().GetArray('cleanIDX'))
# remove last array
narr = cleanmesh.GetPointData().GetNumberOfArrays()
cleanmesh.GetPointData().RemoveArray(narr - 1)
return cleanmesh, origID
else:
return cleanmesh
def get_region(mesh, mesh_out, region):
"""
From a region with two connected components,
get either first or second connected component
and save them to mesh_out.
Returns the output mesh
"""
# Get region
cc = vtk.vtkPolyDataConnectivityFilter()
cc.SetInputData(mesh)
cc.SetExtractionModeToSpecifiedRegions()
cc.AddSpecifiedRegion(region)
cc.Update()
mesh_1 = cc.GetOutput(0)
# Remove connected points
clean = vtk.vtkCleanPolyData()
clean.SetInputData(mesh_1)
clean.Update()
mesh_1 = clean.GetOutput(0)
# Save
rd = vtk.vtkPolyDataWriter()
rd.SetInputData(mesh_1)
rd.SetFileName(mesh_out)
rd.Write()
return mesh_1
def readMeshFile(filename, verbose=False):
"""Read mesh file.
The input format is determined by file name extension. Degenerate data gets
removed and polygons get split into triangles to support varios restrictive
output formats."""
informat = path.splitext(options.infilename)[1].strip('.')
# set reader based on filename extension
if informat=='stl':
reader = vtk.vtkSTLReader()
elif informat=='vtk':
reader = vtk.vtkPolyDataReader()
elif informat=='obj':
reader = vtk.vtkMNIObjectReader()
#elif informat=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format' + informat)
reader.SetFileName(filename)
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(clean.GetOutputPort())
#triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work
if verbose:
print "read", filename
return triangles
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
if (self.GroupId != -1) & (self.GroupIdsArrayName != ''):
self.Surface.GetPointData().SetActiveScalars(
self.GroupIdsArrayName)
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInput(self.Surface)
connectivityFilter.ColorRegionsOff()
connectivityFilter.SetExtractionModeToLargestRegion()
if self.GroupId != -1:
connectivityFilter.ScalarConnectivityOn()
scalarRange = [self.GroupId, self.GroupId]
connectivityFilter.SetScalarRange(scalarRange)
connectivityFilter.Update()
self.Surface = connectivityFilter.GetOutput()
if self.CleanOutput == 1:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(connectivityFilter.GetOutput())
cleaner.Update()
self.Surface = cleaner.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
if (self.GroupId != -1) & (self.GroupIdsArrayName!=''):
self.Surface.GetPointData().SetActiveScalars(self.GroupIdsArrayName)
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInput(self.Surface)
connectivityFilter.ColorRegionsOff()
connectivityFilter.SetExtractionModeToLargestRegion()
if self.GroupId != -1:
connectivityFilter.ScalarConnectivityOn()
scalarRange = [self.GroupId,self .GroupId]
connectivityFilter.SetScalarRange(scalarRange)
connectivityFilter.Update()
self.Surface = connectivityFilter.GetOutput()
if self.CleanOutput == 1:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(connectivityFilter.GetOutput())
cleaner.Update()
self.Surface = cleaner.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def cleanMesh(mesh, connectivityFilter=False):
try:
connect = vtk.vtkPolyDataConnectivityFilter()
clean = vtk.vtkCleanPolyData()
if (connectivityFilter):
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
connect.SetInputData(mesh)
else:
connect.SetInput(mesh)
connect.SetExtractionModeToLargestRegion()
clean.SetInputConnection(connect.GetOutputPort())
else:
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
clean.SetInputData(mesh)
else:
clean.SetInput(mesh)
clean.Update()
print("Surface cleaned")
m2 = clean.GetOutput()
print(" ", m2.GetNumberOfPolys(), "polygons")
return m2
except:
print("Surface cleaning failed")
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(
exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def sphere(resolution=3, size=1):
grid = vtk.vtkAppendPolyData()
# add the center to the mesh
center = vtk.vtkPolyData()
center.SetPoints(vtk.vtkPoints())
center.GetPoints().InsertNextPoint(0, 0, 0)
grid.AddInput(center)
# add spheres of increasing complexity
subdivisions = 0
radius = 0
for i in range(resolution - 1):
radius += float(size) / float(resolution - 1)
sphere = nice_sphere(radius / 2.0, subdivisions)
grid.AddInput(sphere)
subdivisions += 1
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(grid.GetOutput())
mesh = vtk.vtkDelaunay3D()
mesh.SetInput(cleaner.GetOutput())
return mesh
def getPatch(self, inputModel, inputCurve):
# Clip model with curve
loop = vtk.vtkSelectPolyData()
loop.SetLoop(inputCurve)
loop.GenerateSelectionScalarsOn()
loop.SetInputData(inputModel)
loop.SetSelectionModeToLargestRegion()
clip = vtk.vtkClipPolyData()
clip.InsideOutOn()
clip.SetInputConnection(loop.GetOutputPort())
clip.GenerateClippedOutputOn()
clip.Update()
extractLargestPart = False
clippedOutput = clip.GetOutput(
) if extractLargestPart else clip.GetClippedOutput()
connectivity = vtk.vtkConnectivityFilter()
connectivity.SetInputData(clippedOutput)
connectivity.Update()
clippedOutput2 = connectivity.GetOutput()
# Remove unused points
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputData(clippedOutput2)
cleaner.Update()
return cleaner.GetOutput()
def MakeTorus():
"""
Make a torus as the source.
:return: vtkPolyData with normal and scalar data.
"""
source = vtk.vtkSuperquadricSource()
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
return CalculateCurvatures(MakeElevations(cleaner.GetOutput()))
def getregionsrange(polydata):
"""Return range of connected regions."""
# extract surface
surfer = vtk.vtkDataSetSurfaceFilter()
surfer.SetInput(polydata)
surfer.Update()
# clean before connectivity filter
# to avoid artificial regionIds
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(surfer.GetOutput())
cleaner.Update()
# extract all connected regions
connect = vtk.vtkPolyDataConnectivityFilter()
connect.SetInput(cleaner.GetOutput())
connect.SetExtractionModeToAllRegions()
connect.ColorRegionsOn()
connect.Update()
# extract surface
surfer = vtk.vtkDataSetSurfaceFilter()
surfer.SetInput(connect.GetOutput())
surfer.Update()
# get range
regions = surfer.GetOutput().GetPointData().GetArray('RegionId')
regionsrange = regions.GetRange()
return regionsrange
def runCleaningPointCloud(self, projectedLM, sphere, spacingPercentage):
# Convert projected surface points to a VTK array for transform
p = [0, 0, 0]
targetPoints = vtk.vtkPoints()
for i in range(projectedLM.GetNumberOfFiducials()):
projectedLM.GetMarkupPoint(0, i, p)
targetPoints.InsertNextPoint(p)
print("inserting vtk point: ", p)
pointPD = vtk.vtkPolyData()
pointPD.SetPoints(targetPoints)
glyphFilter = vtk.vtkGlyph3D()
glyphFilter.SetInputData(pointPD)
glyphFilter.Update()
glyphPD = glyphFilter.GetOutput()
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetTolerance(spacingPercentage)
cleanFilter.SetInputData(glyphPD)
cleanFilter.Update()
outputPoints = cleanFilter.GetOutput()
sphereSampleLMNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLMarkupsFiducialNode', "PseudoLandmarks")
sphereSampleLMNode.CreateDefaultDisplayNodes()
for i in range(outputPoints.GetNumberOfPoints()):
point = outputPoints.GetPoint(i)
sphereSampleLMNode.AddFiducialFromArray(point)
print("inserting fiducial point: ", p)
landmarkTypeSemi = True
self.setAllLandmarksType(sphereSampleLMNode, landmarkTypeSemi)
return sphereSampleLMNode
def DisplayPointCloud(self, pts, min, max):
self.p = vtk.vtkPoints()
vertices = vtk.vtkCellArray()
#load up points
for i in pts:
pId = self.p.InsertNextPoint(i)
vertices.InsertNextCell(1)
vertices.InsertCellPoint(pId)
pC = vtk.vtkPolyData()
pC.SetPoints(self.p)
pC.SetVerts(vertices)
self.Pmapper = vtk.vtkDataSetMapper()
self.Pmapper.SetInputData(pC)
self.pointCloud = vtk.vtkCleanPolyData()
self.pointCloud.SetInputData(pC)
self.Pmapper.SetInputConnection(self.pointCloud.GetOutputPort())
self.pointActor = vtk.vtkActor()
self.pointActor.SetMapper(self.Pmapper)
self.pointActor.GetProperty().SetColor(0.2784, 0.6745, 0.6941)
self.ren.AddActor(self.pointActor)
limits = np.array([min[0], max[0], min[1], max[1], min[2], max[2]])
self.AddAxis(limits, 1)
self.ui.vtkWidget.update()
self.ren.ResetCamera()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: no Surface.')
if self.WidgetType == "box":
self.ClipFunction = vtk.vtkPlanes()
elif self.WidgetType == "sphere":
self.ClipFunction = vtk.vtkSphere()
self.Clipper = vtk.vtkClipPolyData()
self.Clipper.SetInput(self.Surface)
self.Clipper.SetClipFunction(self.ClipFunction)
self.Clipper.GenerateClippedOutputOn()
self.Clipper.InsideOutOn()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self.Surface)
mapper.ScalarVisibilityOff()
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
if self.WidgetType == "box":
self.ClipWidget = vtk.vtkBoxWidget()
self.ClipWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
self.ClipWidget.GetFaceProperty().SetOpacity(0.25)
elif self.WidgetType == "sphere":
self.ClipWidget = vtk.vtkSphereWidget()
self.ClipWidget.GetSphereProperty().SetColor(0.6,0.6,0.2)
self.ClipWidget.GetSphereProperty().SetOpacity(0.25)
self.ClipWidget.GetSelectedSphereProperty().SetColor(0.6,0.0,0.0)
self.ClipWidget.GetSelectedSphereProperty().SetOpacity(0.75)
self.ClipWidget.SetRepresentationToSurface()
self.ClipWidget.SetPhiResolution(20)
self.ClipWidget.SetThetaResolution(20)
self.ClipWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.Display()
self.Transform = vtk.vtkTransform()
self.ClipWidget.GetTransform(self.Transform)
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
if self.CleanOutput == 1:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(self.Surface)
cleaner.Update()
self.Surface = cleaner.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def cleanerAndTriangleFilter(self, inputModel):
cleanerPolydata = vtk.vtkCleanPolyData()
cleanerPolydata.SetInputData(inputModel.GetPolyData())
cleanerPolydata.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputData(cleanerPolydata.GetOutput())
triangleFilter.Update()
inputModel.SetAndObservePolyData(triangleFilter.GetOutput())
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(self.Surface)
cleaner.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInput(cleaner.GetOutput())
triangleFilter.Update()
self.Surface = triangleFilter.GetOutput()
if self.ElementSizeMode == 'edgelength':
self.TargetArea = 0.25 * 3.0**0.5 * self.TargetEdgeLength**2
elif self.ElementSizeMode == 'edgelengtharray':
calculator = vtk.vtkArrayCalculator()
calculator.SetInput(self.Surface)
calculator.AddScalarArrayName(self.TargetEdgeLengthArrayName,0)
calculator.SetFunction("%f^2 * 0.25 * sqrt(3) * %s^2" % (self.TargetEdgeLengthFactor,self.TargetEdgeLengthArrayName))
calculator.SetResultArrayName(self.TargetAreaArrayName)
calculator.Update()
self.MaxArea = 0.25 * 3.0**0.5 * self.MaxEdgeLength**2
self.MinArea = 0.25 * 3.0**0.5 * self.MinEdgeLength**2
self.Surface = calculator.GetOutput()
surfaceRemeshing = vtkvmtk.vtkvmtkPolyDataSurfaceRemeshing()
surfaceRemeshing.SetInput(self.Surface)
if self.CellEntityIdsArrayName:
surfaceRemeshing.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName)
if self.ElementSizeMode in ['area','edgelength']:
surfaceRemeshing.SetElementSizeModeToTargetArea()
elif self.ElementSizeMode in ['areaarray','edgelengtharray']:
surfaceRemeshing.SetElementSizeModeToTargetAreaArray()
surfaceRemeshing.SetTargetAreaArrayName(self.TargetAreaArrayName)
else:
self.PrintError('Error: unsupported ElementSizeMode.')
surfaceRemeshing.SetTargetArea(self.TargetArea)
surfaceRemeshing.SetTargetAreaFactor(self.TargetAreaFactor)
surfaceRemeshing.SetMaxArea(self.MaxArea)
surfaceRemeshing.SetMinArea(self.MinArea)
surfaceRemeshing.SetNumberOfIterations(self.NumberOfIterations)
surfaceRemeshing.SetNumberOfConnectivityOptimizationIterations(self.NumberOfConnectivityOptimizationIterations)
surfaceRemeshing.SetRelaxation(self.Relaxation)
surfaceRemeshing.SetMinAreaFactor(self.MinAreaFactor)
surfaceRemeshing.SetAspectRatioThreshold(self.AspectRatioThreshold)
surfaceRemeshing.SetInternalAngleTolerance(self.InternalAngleTolerance)
surfaceRemeshing.SetNormalAngleTolerance(self.NormalAngleTolerance)
surfaceRemeshing.SetCollapseAngleThreshold(self.CollapseAngleThreshold)
surfaceRemeshing.SetPreserveBoundaryEdges(self.PreserveBoundaryEdges)
surfaceRemeshing.Update()
self.Surface = surfaceRemeshing.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def cleanPolyData(polyData):
cleanFilt = vtk.vtkCleanPolyData()
cleanFilt.SetConvertLinesToPoints(0)
cleanFilt.SetConvertPolysToLines(0)
cleanFilt.SetConvertStripsToPolys(0)
cleanFilt.SetPointMerging(1)
cleanFilt.SetInputData(polyData)
cleanFilt.Update()
return cleanFilt.GetOutput()
def computeComponents(vertices, faces):
pts, tris = arrayToPolydata(vertices, faces)
polys = vtk.vtkPolyData()
polys.SetPoints(pts)
polys.SetPolys(tris)
polys.Update()
cleanFilter = vtk.vtkCleanPolyData()
#cleanFilter.PointMergingOff()
cleanFilter.ConvertStripsToPolysOff()
cleanFilter.ConvertPolysToLinesOff()
cleanFilter.ConvertLinesToPointsOff()
cleanFilter.SetInput(polys)
cleanFilter.Update()
connFilter = vtk.vtkPolyDataConnectivityFilter()
connFilter.ScalarConnectivityOff()
connFilter.SetExtractionModeToAllRegions()
connFilter.SetInput(cleanFilter.GetOutput())
connFilter.Update()
nregions = connFilter.GetNumberOfExtractedRegions()
print "Regions extracted: %d" % (nregions)
components = []
for i in range(nregions):
connFilter = vtk.vtkPolyDataConnectivityFilter()
connFilter.ScalarConnectivityOff()
connFilter.SetExtractionModeToSpecifiedRegions()
connFilter.AddSpecifiedRegion(i)
connFilter.SetInput(cleanFilter.GetOutput())
connFilter.Update()
cFilter = vtk.vtkCleanPolyData()
# cFilter.ConvertStripsToPolysOff()
# cFilter.ConvertPolysToLinesOff()
# cFilter.ConvertLinesToPointsOff()
cFilter.SetInput(connFilter.GetOutput())
cFilter.Update()
v,f = polydataToArray(cFilter.GetOutput())
components.append([v,f])
return components
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# initialise any mixins we might have
NoConfigModuleMixin.__init__(self)
mm = self._module_manager
self._cleaner = vtk.vtkCleanPolyData()
self._tf = vtk.vtkTriangleFilter()
self._tf.SetInput(self._cleaner.GetOutput())
self._wspdf = vtk.vtkWindowedSincPolyDataFilter()
# self._wspdf.SetNumberOfIterations(50)
self._wspdf.SetInput(self._tf.GetOutput())
self._wspdf.SetProgressText("smoothing")
self._wspdf.SetProgressMethod(lambda s=self, mm=mm: mm.vtk_progress_cb(s._wspdf))
self._cleaner2 = vtk.vtkCleanPolyData()
self._cleaner2.SetInput(self._wspdf.GetOutput())
self._curvatures = vtk.vtkCurvatures()
self._curvatures.SetCurvatureTypeToMean()
self._curvatures.SetInput(self._cleaner2.GetOutput())
self._tf.SetProgressText("triangulating")
self._tf.SetProgressMethod(lambda s=self, mm=mm: mm.vtk_progress_cb(s._tf))
self._curvatures.SetProgressText("calculating curvatures")
self._curvatures.SetProgressMethod(lambda s=self, mm=mm: mm.vtk_progress_cb(s._curvatures))
self._inputFilter = self._tf
self._inputPoints = None
self._inputPointsOID = None
self._giaGlenoid = None
self._outsidePoints = None
self._outputPolyDataARB = vtk.vtkPolyData()
self._outputPolyDataHM = vtk.vtkPolyData()
self._createViewFrame("Test Module View", {"vtkTriangleFilter": self._tf, "vtkCurvatures": self._curvatures})
self._viewFrame.Show(True)
def CentreLinePolyData(self):
"""Compute centrelines based on the profile, reusing our
memoed copy or reading from the cache file if possible.
"""
if (os.path.exists(self.CentreLineFile ) and
os.path.getmtime(self.CentreLineFile ) > os.path.getmtime(self.StlFile) and
os.path.getmtime(self.CentreLineFile ) > os.path.getmtime(self.FileName)):
# Cached!
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(self.CentreLineFile)
reader.Update()
return reader.GetOutput()
# Have to compute it
# Read the STL file
reader = vtk.vtkSTLReader()
reader.SetFileName(profile.StlFile)
# Find the seed points for centreline calculation
# Use points one iolet radius back along the normal.
outletPts = []
def scale(iolet):
pt = (iolet.Centre - iolet.Radius * iolet.Normal)
pt = pt / self.LengthUnit
return pt.magnitude
for iolet in self.Iolets:
if isinstance(iolet._iolet, Inlet):
inletPt = scale(iolet)
else:
outletPts.append(scale(iolet))
pass
continue
srcPts, tgtPts = FindSeeds(reader, inletPt, outletPts)
# Lazy import since it's so slow!
from vmtk import vtkvmtk
centreliner = vtkvmtk.vtkvmtkPolyDataCenterlines()
centreliner.SetInputConnection(reader.GetOutputPort())
centreliner.SetSourceSeedIds(srcPts)
centreliner.SetTargetSeedIds(tgtPts)
centreliner.SetRadiusArrayName("radius")
centreliner.SetCostFunction("1/R")
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(centreliner.GetOutputPort())
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputConnection(cleaner.GetOutputPort())
writer.SetFileName(self.CentreLineFile)
writer.Write()
return cleaner.GetOutput()
def trim_mesh_with_cone(mesh, cone_point, cone_normal, cone_radius):
"""
returns a mesh that contains only the triangles that where inside of the cone
"""
cone_end = cone_point + cone_normal*100.0
sq_radius = cone_radius*cone_radius
w = cone_point
v = cone_end
n = w - v
v_w_sq_len = dist2(v, w)
points = mesh.GetPoints().GetData()
cell_array = mesh.GetPolys()
polygons = cell_array.GetData()
triangles = vtk.vtkCellArray()
for i in xrange(0, cell_array.GetNumberOfCells()):
triangle = [polygons.GetValue(j) for j in xrange(i*4+1, i*4+4)]
p = points.GetTuple(triangle[0])
delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
if delta.dot(delta) > sq_radius:
continue
p = points.GetTuple(triangle[1])
delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
if delta.dot(delta) > sq_radius:
continue
p = points.GetTuple(triangle[2])
delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
if delta.dot(delta) > sq_radius:
continue
cell = vtk.vtkTriangle()
pointIds = cell.GetPointIds()
pointIds.SetId(0, triangle[0])
pointIds.SetId(1, triangle[1])
pointIds.SetId(2, triangle[2])
triangles.InsertNextCell(cell)
# Create a polydata object
trianglePolyData = vtk.vtkPolyData()
# Add the geometry and topology to the polydata
trianglePolyData.SetPoints(mesh.GetPoints())
trianglePolyData.SetPolys(triangles)
trianglePolyData.Update()
#run the clean function here to remove the points that are not used
cleanPolyData = vtk.vtkCleanPolyData()
cleanPolyData.SetInput(trianglePolyData)
cleanPolyData.Update()
trimmed_mesh = cleanPolyData.GetOutput()
return trimmed_mesh
def DeformSurface(self):
# interpolate and sample the displacement norms over the surface
rbf = vtkvmtkcontrib.vtkvmtkRBFInterpolation2()
rbf.SetSource(self.SourceSpheres)
rbf.SetRBFTypeToBiharmonic()
rbf.ComputeCoefficients()
sampler = vtkvmtkcontrib.vtkvmtkPolyDataSampleFunction()
sampler.SetInput(self.Surface)
sampler.SetImplicitFunction(rbf)
sampler.SetSampleArrayName("DisplacementNorms")
sampler.Update()
sampArray = sampler.GetOutput().GetPointData().GetArray("DisplacementNorms")
##Clamp the negative values to 0 and the positive values to one in a weight array
calculator = vtk.vtkArrayCalculator()
calculator.SetInput(sampler.GetOutput())
calculator.AddScalarArrayName("DisplacementNorms")
calculator.SetFunction("if( DisplacementNorms > 0 , iHat, jHat)")
calculator.SetResultArrayName("Weights")
calculator.SetResultArrayType(vtk.VTK_FLOAT)
calculator.Update()
# Create the transform
thinPlateSplineTransform = vtk.vtkThinPlateSplineTransform()
thinPlateSplineTransform.SetBasisToR()
thinPlateSplineTransform.SetSourceLandmarks(self.SourcePoints)
thinPlateSplineTransform.SetTargetLandmarks(self.TargetPoints)
transform = vtk.vtkTransform()
transform.Identity()
transform2 = vtk.vtkTransform()
transform2.Identity()
# Apply weighted transform
transformFilter = vtk.vtkWeightedTransformFilter()
transformFilter.SetInput(calculator.GetOutput())
transformFilter.SetNumberOfTransforms(3)
transformFilter.SetWeightArray("Weights")
transformFilter.SetTransform(thinPlateSplineTransform, 0)
transformFilter.SetTransform(transform, 1)
transformFilter.SetTransform(transform2, 2)
transformFilter.Update()
normalsFilter = vtk.vtkPolyDataNormals()
normalsFilter.SetInput(transformFilter.GetOutput())
normalsFilter.Update()
# FIXME: the normal filter apparently introduced some holes in some meshes (wtf?). This filter cleans the mesh
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInput(normalsFilter.GetOutput())
cleanFilter.Update()
self.DeformedSurface = cleanFilter.GetOutput()
def applyFilters(self, state):
surface = None
surface = state.inputModelNode.GetPolyDataConnection()
if state.decimation:
triangle = vtk.vtkTriangleFilter()
triangle.SetInputConnection(surface)
decimation = vtk.vtkDecimatePro()
decimation.SetTargetReduction(state.reduction)
decimation.SetBoundaryVertexDeletion(state.boundaryDeletion)
decimation.PreserveTopologyOn()
decimation.SetInputConnection(triangle.GetOutputPort())
surface = decimation.GetOutputPort()
if state.smoothing:
if state.smoothingMethod == "Laplace":
smoothing = vtk.vtkSmoothPolyDataFilter()
smoothing.SetBoundarySmoothing(state.boundarySmoothing)
smoothing.SetNumberOfIterations(state.laplaceIterations)
smoothing.SetRelaxationFactor(state.laplaceRelaxation)
smoothing.SetInputConnection(surface)
surface = smoothing.GetOutputPort()
elif state.smoothingMethod == "Taubin":
smoothing = vtk.vtkWindowedSincPolyDataFilter()
smoothing.SetBoundarySmoothing(state.boundarySmoothing)
smoothing.SetNumberOfIterations(state.taubinIterations)
smoothing.SetPassBand(state.taubinPassBand)
smoothing.SetInputConnection(surface)
surface = smoothing.GetOutputPort()
if state.normals:
normals = vtk.vtkPolyDataNormals()
normals.AutoOrientNormalsOn()
normals.SetFlipNormals(state.flipNormals)
normals.SetSplitting(state.splitting)
normals.SetFeatureAngle(state.featureAngle)
normals.ConsistencyOn()
normals.SetInputConnection(surface)
surface = normals.GetOutputPort()
if state.cleaner:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(surface)
surface = cleaner.GetOutputPort()
if state.connectivity:
connectivity = vtk.vtkPolyDataConnectivityFilter()
connectivity.SetExtractionModeToLargestRegion()
connectivity.SetInputConnection(surface)
surface = connectivity.GetOutputPort()
state.outputModelNode.SetPolyDataConnection(surface)
return True
def concomp(opts, argv): p = nv.readVTK(argv[0]) c = vtk.vtkPolyDataConnectivityFilter() c.SetInput(p) c.SetExtractionModeToLargestRegion() c.Update() d = vtk.vtkCleanPolyData() d.SetInput(c.GetOutput()) d.Update() p = d.GetOutput() nv.writeVTK(argv[1],p)
def Merge(polydata_list):
append = vtk.vtkAppendPolyData()
for polydata in polydata_list:
triangle = vtk.vtkTriangleFilter()
triangle.SetInputData(polydata)
append.AddInputData(triangle.GetOutput())
clean = vtk.vtkCleanPolyData()
clean.SetInputData(append.GetOutput())
return append.GetOutput()
def prepareModel(self, polyData):
'''
'''
# import the vmtk libraries
try:
import vtkvmtkComputationalGeometryPython as vtkvmtkComputationalGeometry
import vtkvmtkMiscPython as vtkvmtkMisc
except ImportError:
logging.error("Unable to import the SlicerVmtk libraries")
capDisplacement = 0.0
surfaceCleaner = vtk.vtkCleanPolyData()
surfaceCleaner.SetInputData(polyData)
surfaceCleaner.Update()
surfaceTriangulator = vtk.vtkTriangleFilter()
surfaceTriangulator.SetInputData(surfaceCleaner.GetOutput())
surfaceTriangulator.PassLinesOff()
surfaceTriangulator.PassVertsOff()
surfaceTriangulator.Update()
# new steps for preparation to avoid problems because of slim models (f.e. at stenosis)
subdiv = vtk.vtkLinearSubdivisionFilter()
subdiv.SetInputData(surfaceTriangulator.GetOutput())
subdiv.SetNumberOfSubdivisions(1)
subdiv.Update()
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputData(subdiv.GetOutput())
smooth.SetNumberOfIterations(20)
smooth.SetPassBand(0.1)
smooth.SetBoundarySmoothing(1)
smooth.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(smooth.GetOutput())
normals.SetAutoOrientNormals(1)
normals.SetFlipNormals(0)
normals.SetConsistency(1)
normals.SplittingOff()
normals.Update()
surfaceCapper = vtkvmtkComputationalGeometry.vtkvmtkCapPolyData()
surfaceCapper.SetInputData(normals.GetOutput())
surfaceCapper.SetDisplacement(capDisplacement)
surfaceCapper.SetInPlaneDisplacement(capDisplacement)
surfaceCapper.Update()
outPolyData = vtk.vtkPolyData()
outPolyData.DeepCopy(surfaceCapper.GetOutput())
return outPolyData
def PickCallback(self, obj):
picker = vtk.vtkPointPicker()
eventPosition = self.vmtkRenderer.RenderWindowInteractor.GetEventPosition()
result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer)
# We treat result as a boolean value (which can also be nonetype if a selection outside the render windw is made)
# If the value of result is False or None, then an invalid actor was selected in the scene.
if result is None:
return
elif result == 0:
return
# find the value of "RegionId" stored in the vtkPolyData PointData array. This is a unique number
# which is generated for each connected surface point by the allRegionConnectivity
# vtkPolyDataConnectivityFilter function
pickedPointId = picker.GetPointId()
self.CurrentPickedActor = picker.GetActor()
self.CurrentPickedPolyData = self.CurrentPickedActor.GetMapper().GetInputAsDataSet()
regionId = self.CurrentPickedPolyData.GetPointData().GetArray('RegionId').GetValue(pickedPointId)
# extract only the desired region Id from the dataset
isolatedFilter = vtk.vtkPolyDataConnectivityFilter()
isolatedFilter.SetInputData(self.CurrentPickedPolyData)
isolatedFilter.SetExtractionModeToSpecifiedRegions()
isolatedFilter.AddSpecifiedRegion(regionId)
# remove all points not in the extracted cells
cleanedFilter = vtk.vtkCleanPolyData()
cleanedFilter.SetInputConnection(isolatedFilter.GetOutputPort())
cleanedFilter.Update()
outputSurface = cleanedFilter.GetOutput()
# create a new mapper and actor for this extracted surface object
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(outputSurface)
mapper.ScalarVisibilityOff()
mapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(1.0, 0.0, 0.0) # red color
actor.GetProperty().SetDiffuse(1.0)
actor.GetProperty().SetSpecular(0.2)
actor.GetProperty().SetRepresentationToSurface()
actor.GetProperty().EdgeVisibilityOff()
# place the extracted surface object's actor instance in the necessary render windows
# and lists to log it's selection
self.PastPickedActorList.append(actor)
self._OutputPolyDataList.append(outputSurface)
self.vmtkRenderer.Renderer.AddActor(actor)
self.vmtkRenderer.RenderWindow.Render()
return
def GenTorus(programArguments):
''' programArguments: ini file containing model parameters'''
# Load relevant parameters from ini file
conf = ConfigObj(programArguments)
parameters = conf['Parameters']
majorCirc = parameters['surfaceLength']
minorCirc = parameters['surfaceWidth']
thetaMesh = parameters['xMesh']
# Minor and major radii
r = float(minorCirc)/(2*np.pi)
R = float(majorCirc)/(2*np.pi)
# Mesh sizes
thetaResolution = int(thetaMesh)
phiResolution = int(thetaResolution*(R/r))
# Generate a torus
torusSource = vtk.vtkSuperquadricSource()
torusSource.SetCenter(0.0, 0.0, 0.0)
torusSource.SetScale(1.0, 1.0, 1.0)
torusSource.SetToroidal(1)
torusSource.SetThetaRoundness(1)
torusSource.SetPhiRoundness(1)
# SuperquadricSource reverses phi and theta to be confusing - this is not an error
torusSource.SetPhiResolution(thetaResolution)
torusSource.SetThetaResolution(phiResolution)
# Don't change these!
torusSource.SetSize(R + r)
torusSource.SetThickness(r/R)
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close. First convert quads into triangles
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(torusSource.GetOutputPort())
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.00005)
cleaner.Update()
outputFileName = "torus_R" + majorCirc + "_r" + minorCirc + "_mesh" + thetaMesh + ".vtp"
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputData(cleaner.GetOutput())
writer.SetFileName(outputFileName)
writer.Update()
print "Saving output to file", outputFileName
def getDual( pd ):
'''Get the dual of a vtkPolyData. The finite parts only.'''
pd.BuildLinks()
cells = vtk.vtkCellArray()
points = vtk.vtkPoints()
for iPt in range(pd.GetNumberOfPoints()):
neighbor_cellIds = vtk.vtkIdList()
pd.GetPointCells( iPt, neighbor_cellIds )
if neighbor_cellIds.GetNumberOfIds() < 3:
continue
# sort the neighbor_cellIds into a ring around iPt
sorted_neighbor_cellIds = [ neighbor_cellIds.GetId( 0 ) ]
for it in range( neighbor_cellIds.GetNumberOfIds() - 1 ):
for iicell in range( 1, neighbor_cellIds.GetNumberOfIds() ):
icell = neighbor_cellIds.GetId( iicell )
if icell in sorted_neighbor_cellIds:
continue
# does this cell share exactly two vertices with the last one in the list?
if getNumberOfPointsSharedByTwoCells( pd, sorted_neighbor_cellIds[-1], icell ) == 2:
sorted_neighbor_cellIds += [ icell ]
break
if len( sorted_neighbor_cellIds ) < neighbor_cellIds.GetNumberOfIds():
continue # was a boundary vertex or non-manifold
if not getNumberOfPointsSharedByTwoCells( pd, sorted_neighbor_cellIds[-1], sorted_neighbor_cellIds[0] ) == 2:
continue # boundary vertex, in the case where cell id 0 was on the boundary
# make a face around this vertex: a new point at each centroid of the neighboring cells
cells.InsertNextCell( neighbor_cellIds.GetNumberOfIds() )
for id in sorted_neighbor_cellIds:
# find centroid of this cell
neighbor_verts = vtk.vtkIdList()
pd.GetCellPoints( id, neighbor_verts )
c = (0,0,0)
for iiv in range(neighbor_verts.GetNumberOfIds()):
iv = neighbor_verts.GetId(iiv)
p = pd.GetPoint( iv )
c = add( c, p )
c = mul( c, 1.0 / neighbor_verts.GetNumberOfIds() )
# insert the centroid as a point and as an index into the new face
cells.InsertCellPoint( points.InsertNextPoint( c ) )
dual_pd = vtk.vtkPolyData()
dual_pd.SetPoints( points )
dual_pd.SetPolys( cells )
# merge duplicate points
cleaner = vtk.vtkCleanPolyData()
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
cleaner.SetInputData( dual_pd )
else:
cleaner.SetInput( dual_pd )
cleaner.SetTolerance(0.0001)
cleaner.Update()
return cleaner.GetOutput()
def extractlargestregion(polydata):
# NOTE: preventive measures: clean before connectivity filter
# to avoid artificial regionIds
# It slices the surface down the middle
surfer = vtk.vtkDataSetSurfaceFilter()
surfer.SetInputData(polydata)
surfer.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(surfer.GetOutputPort())
cleaner.Update()
connect = vtk.vtkPolyDataConnectivityFilter()
connect.SetInputConnection(cleaner.GetOutputPort())
connect.SetExtractionModeToLargestRegion()
connect.Update()
# leaves phantom points ....
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(connect.GetOutputPort())
cleaner.Update()
return cleaner.GetOutput()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputData(self.Surface)
cleaner.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(cleaner.GetOutputPort())
triangleFilter.Update()
self.Surface = triangleFilter.GetOutput()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
if (self.GroupId != -1) and (self.GroupIdsArrayName!=''):
self.Surface.GetPointData().SetActiveScalars(self.GroupIdsArrayName)
barycenter = [0.0,0.0,0.0]
if self.Method == 'closest' and self.ClosestPoint == None:
n = self.ReferenceSurface.GetNumberOfPoints()
for i in range(n):
point = self.ReferenceSurface.GetPoint(i)
barycenter[0] += point[0]
barycenter[1] += point[1]
barycenter[2] += point[2]
barycenter[0] /= n
barycenter[1] /= n
barycenter[2] /= n
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInputData(self.Surface)
connectivityFilter.ColorRegionsOff()
if self.Method == 'largest':
connectivityFilter.SetExtractionModeToLargestRegion()
elif self.Method == 'closest':
connectivityFilter.SetExtractionModeToClosestPointRegion()
if self.ClosestPoint:
connectivityFilter.SetClosestPoint(self.ClosestPoint)
else:
connectivityFilter.SetClosestPoint(barycenter)
elif self.Method == 'all':
connectivityFilter.SetExtractionModeToAllRegions()
connectivityFilter.ColorRegionsOn()
if self.GroupId != -1:
connectivityFilter.ScalarConnectivityOn()
scalarRange = [self.GroupId,self.GroupId]
connectivityFilter.SetScalarRange(scalarRange)
connectivityFilter.Update()
self.Surface = connectivityFilter.GetOutput()
if self.CleanOutput == 1:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(connectivityFilter.GetOutputPort())
cleaner.Update()
self.Surface = cleaner.GetOutput()
def main():
files = glob.glob(os.path.join(sys.argv[1], '*'))
for f in sorted(files):
ply_reader = vtk.vtkPLYReader()
ply_reader.SetFileName(f)
ply_reader.Update()
nc = test_connectivity(ply_reader.GetOutput())
print f, nc
clean = vtk.vtkCleanPolyData()
clean.SetInput(ply_reader.GetOutput())
clean.Update()
print clean.GetOutput().GetNumberOfPoints(), clean.GetOutput().GetNumberOfCells()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInput(self.Surface)
triangleFilter.Update()
decimationFilter = vtk.vtkDecimatePro()
decimationFilter.SetInput(triangleFilter.GetOutput())
decimationFilter.SetTargetReduction(self.TargetReduction)
decimationFilter.SetBoundaryVertexDeletion(self.BoundaryVertexDeletion)
decimationFilter.PreserveTopologyOn()
decimationFilter.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(decimationFilter.GetOutput())
cleaner.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInput(cleaner.GetOutput())
triangleFilter.Update()
self.Surface = triangleFilter.GetOutput()
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
