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()