def surfaceRecon(self):
pointSource = vtk.vtkProgrammableSource()
def readPoints():
output = pointSource.GetPolyDataOutput()
#points = vtk.vtkPoints()
output.SetPoints(self.vtkPoints)
pointSource.SetExecuteMethod(readPoints)
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputConnection(pointSource.GetOutputPort())
print(surf)
contour = vtk.vtkContourFilter()
contour.SetInputConnection(surf.GetOutputPort())
contour.SetValue(0, 0.0)
print(contour)
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contour.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInputConnection(reverse.GetOutputPort())
contourMapper.ScalarVisibilityOff()
print(contourMapper)
contourActor = vtk.vtkActor()
contourActor.SetMapper(contourMapper)
print(contourActor)
return contourActor
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkReverseSense(), 'Processing.',
('vtkPolyData',), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def MakeGlyphs(src, normal_reverse, normal_arrowAtPoint):
reverse = vtk.vtkReverseSense()
maskPts = vtk.vtkMaskPoints()
maskPts.SetOnRatio(1)
if normal_reverse:
reverse.SetInputData(src)
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
maskPts.SetInputConnection(reverse.GetOutputPort())
else:
maskPts.SetInputData(src)
arrow = vtk.vtkArrowSource()
if normal_arrowAtPoint:
arrow.SetInvert(1)
else:
arrow.SetInvert(0)
arrow.SetTipResolution(16)
arrow.SetTipLength(normal_length)
arrow.SetTipRadius(normal_tip_radius)
glyph = vtk.vtkGlyph3D()
glyph.SetSourceConnection(arrow.GetOutputPort())
glyph.SetInputConnection(maskPts.GetOutputPort())
glyph.SetVectorModeToUseNormal()
glyph.SetScaleFactor(normal_scale)
if normal_scaleByPointScalar:
glyph.SetScaleModeToScaleByScalar()
else:
glyph.SetScaleModeToScaleByVector()
glyph.SetColorModeToColorByScalar()
glyph.OrientOn()
return glyph
def vtkPlotCenterline(self, vtkCenterLine):
"Affichage de la centerline"
self.ren.RemoveActor(self.centerlineActor)
self.vtkRedraw()
self.centerlineActor = None
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(vtkCenterLine.GetOutputPort())
reverse.ReverseCellsOff()
reverse.ReverseNormalsOff()
self.centerLineMapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
self.centerLineMapper.SetInput(reverse.GetOutput())
else:
self.centerLineMapper.SetInputConnection(reverse.GetOutputPort())
self.centerlineActor = vtk.vtkActor()
self.centerlineActor.SetMapper(self.centerLineMapper)
self.centerlineActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
self.centerlineActor.GetProperty().SetSpecularColor(1, 1, 1)
self.centerlineActor.GetProperty().SetSpecular(.4)
self.centerlineActor.GetProperty().SetSpecularPower(50)
self.ren.AddActor(self.centerlineActor)
self.vtkRedraw()
def flipx(pd, c):
""" flip mesh along x-axis and center c (only cx matters) """
# setting up the transform (could be factorised if applied t o several subjects), but not a big overhead
d = tuple([-x for x in c])
transform = vtk.vtkTransform()
transform.PostMultiply()
transform.Translate(d)
transform.Scale(-1, 1, 1)
transform.Translate(c)
t = vtk.vtkTransformPolyDataFilter()
t.SetTransform(transform)
rev = vtk.vtkReverseSense()
# apply
t.SetInputData(pd)
t.Update()
rev.SetInputData(t.GetOutput())
rev.Update()
return rev.GetOutput()
def reverse_lines(self, source):
strip = vtk.vtkStripper()
strip.SetInputData(source)
strip.Update()
reversed = vtk.vtkReverseSense()
reversed.SetInputConnection(strip.GetOutputPort())
reversed.Update()
return reversed.GetOutput()
def createSymmetry(self, inputData, plane):
normal = [0, 0, 0]
origin = [0, 0, 0]
plane.GetNormalWorld(normal)
plane.GetOriginWorld(origin)
vtkPlane = vtk.vtkPlane()
vtkPlane.SetOrigin(origin)
vtkPlane.SetNormal(normal)
clipper = vtk.vtkClipPolyData()
clipper.SetClipFunction(vtkPlane)
clipper.SetInputData(inputData)
clipper.Update()
return cleanFilter.GetOutput()
mirrorMatrix = vtk.vtkMatrix4x4()
mirrorMatrix.SetElement(0, 0, 1 - 2 * normal[0] * normal[0])
mirrorMatrix.SetElement(0, 1, -2 * normal[0] * normal[1])
mirrorMatrix.SetElement(0, 2, -2 * normal[0] * normal[2])
mirrorMatrix.SetElement(1, 0, -2 * normal[0] * normal[1])
mirrorMatrix.SetElement(1, 1, 1 - 2 * normal[1] * normal[1])
mirrorMatrix.SetElement(1, 2, -2 * normal[1] * normal[2])
mirrorMatrix.SetElement(2, 0, -2 * normal[0] * normal[2])
mirrorMatrix.SetElement(2, 1, -2 * normal[1] * normal[2])
mirrorMatrix.SetElement(2, 2, 1 - 2 * normal[2] * normal[2])
translateWorldToPlane = [0, 0, 0]
vtk.vtkMath.Add(translateWorldToPlane, origin, translateWorldToPlane)
translatePlaneOToWorld = [0, 0, 0]
vtk.vtkMath.Add(translatePlaneOToWorld, origin, translatePlaneOToWorld)
vtk.vtkMath.MultiplyScalar(translatePlaneOToWorld, -1)
mirrorTransform = vtk.vtkTransform()
mirrorTransform.SetMatrix(mirrorMatrix)
mirrorTransform.PostMultiply()
mirrorTransform.Identity()
mirrorTransform.Translate(translatePlaneOToWorld)
mirrorTransform.Concatenate(mirrorMatrix)
mirrorTransform.Translate(translateWorldToPlane)
mirrorFilter = vtk.vtkTransformFilter()
mirrorFilter.SetTransform(mirrorTransform)
mirrorFilter.SetInputConnection(clipper.GetOutputPort())
reverseNormalFilter = vtk.vtkReverseSense()
reverseNormalFilter.SetInputConnection(mirrorFilter.GetOutputPort())
reverseNormalFilter.Update()
appendFilter = vtk.vtkAppendPolyData()
appendFilter.AddInputData(clipper.GetOutput())
appendFilter.AddInputData(reverseNormalFilter.GetOutput())
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInputConnection(appendFilter.GetOutputPort())
cleanFilter.Update()
return cleanFilter.GetOutput()
def SetInput(self, sourcePolyData):
mirror_transform = vtk.vtkTransform()
mirror_transform.Scale(-1,1,1)
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetTransform(mirror_transform)
transformer.SetInput(sourcePolyData)
rev = vtk.vtkReverseSense()
rev.SetInput(transformer.GetOutput())
self.AddInput(rev.GetOutput())
self.AddInput(sourcePolyData)
def SetInput(self, sourcePolyData):
mirror_transform = vtk.vtkTransform()
mirror_transform.Scale(-1, 1, 1)
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetTransform(mirror_transform)
transformer.SetInput(sourcePolyData)
rev = vtk.vtkReverseSense()
rev.SetInput(transformer.GetOutput())
self.AddInput(rev.GetOutput())
self.AddInput(sourcePolyData)
def reverse_normals(grid):
polydata_filter = vtk.vtkGeometryFilter()
polydata_filter.SetInputData(grid)
polydata_filter.Update()
polydata = polydata_filter.GetOutput()
reverse = vtk.vtkReverseSense()
reverse.ReverseCellsOn()
reverse.SetInputData(polydata)
reverse.Update()
return reverse.GetOutput()
def _labelmapToPolydata(labelmap, value=1):
discreteCubes = vtk.vtkDiscreteMarchingCubes()
discreteCubes.SetInputData(labelmap)
discreteCubes.SetValue(0, value)
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(discreteCubes.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
return reverse.GetOutput()
def mirror(flt):
tr = vtk.vtkTransform()
tr.Scale(-1, 1, 1)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(flt.GetOutputPort())
rs = vtk.vtkReverseSense()
rs.SetInputConnection(tp.GetOutputPort())
return rs
def flipNormals(actor): # N.B. input argument gets modified
rs = vtk.vtkReverseSense()
setInput(rs, polydata(actor, True))
rs.ReverseNormalsOn()
rs.Update()
poly = rs.GetOutput()
mapper = actor.GetMapper()
setInput(mapper, poly)
mapper.Update()
actor.Modified()
if hasattr(actor, 'poly'): actor.poly = poly
return actor # return same obj for concatenation
def reconstruct(self):
# Read some points. Use a programmable filter to read them.
# Construct the surface and create isosurface.
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetSampleSpacing(1)
surf.SetInputConnection(self.pointSource.GetOutputPort())
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
map = vtk.vtkPolyDataMapper()
map.SetInputConnection(reverse.GetOutputPort())
map.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(map)
surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
surfaceActor.GetProperty().SetSpecularColor(1, 1, 1)
surfaceActor.GetProperty().SetSpecular(.4)
surfaceActor.GetProperty().SetSpecularPower(50)
# Create the RenderWindow, Renderer and both Actors
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
ren.AddActor(surfaceActor)
ren.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
ren.GetActiveCamera().SetPosition(1, 0, 0)
ren.GetActiveCamera().SetViewUp(0, 0, 1)
ren.ResetCamera()
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Elevation(30)
ren.GetActiveCamera().Dolly(1.2)
ren.ResetCameraClippingRange()
return cf
def marchingCubes(self, image, ijkToRasMatrix, threshold):
transformIJKtoRAS = vtk.vtkTransform()
transformIJKtoRAS.SetMatrix(ijkToRasMatrix)
marchingCubes = vtk.vtkMarchingCubes()
marchingCubes.SetInputData(image)
marchingCubes.SetValue(0, threshold)
marchingCubes.ComputeScalarsOn()
marchingCubes.ComputeGradientsOn()
marchingCubes.ComputeNormalsOn()
marchingCubes.ReleaseDataFlagOn()
marchingCubes.Update()
if transformIJKtoRAS.GetMatrix().Determinant() < 0:
reverser = vtk.vtkReverseSense()
reverser.SetInputData(marchingCubes.GetOutput())
reverser.ReverseNormalsOn()
reverser.ReleaseDataFlagOn()
reverser.Update()
correctedOutput = reverser.GetOutput()
else:
correctedOutput = marchingCubes.GetOutput()
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInputData(correctedOutput)
transformer.SetTransform(transformIJKtoRAS)
transformer.ReleaseDataFlagOn()
transformer.Update()
normals = vtk.vtkPolyDataNormals()
normals.ComputePointNormalsOn()
normals.SetInputData(transformer.GetOutput())
normals.SetFeatureAngle(60)
normals.SetSplitting(1)
normals.ReleaseDataFlagOn()
normals.Update()
stripper = vtk.vtkStripper()
stripper.SetInputData(normals.GetOutput())
stripper.ReleaseDataFlagOff()
stripper.Update()
stripper.GetOutput()
result = vtk.vtkPolyData()
result.DeepCopy(stripper.GetOutput())
return result
def marchingCubes(self, image, ijkToRasMatrix, threshold):
transformIJKtoRAS = vtk.vtkTransform()
transformIJKtoRAS.SetMatrix(ijkToRasMatrix)
marchingCubes = vtk.vtkMarchingCubes()
marchingCubes.SetInputData(image)
marchingCubes.SetValue(0, threshold)
marchingCubes.ComputeScalarsOn()
marchingCubes.ComputeGradientsOn()
marchingCubes.ComputeNormalsOn()
marchingCubes.ReleaseDataFlagOn()
marchingCubes.Update()
if transformIJKtoRAS.GetMatrix().Determinant() < 0:
reverser = vtk.vtkReverseSense()
reverser.SetInputData(marchingCubes.GetOutput())
reverser.ReverseNormalsOn()
reverser.ReleaseDataFlagOn()
reverser.Update()
correctedOutput = reverser.GetOutput()
else:
correctedOutput = marchingCubes.GetOutput()
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInputData(correctedOutput)
transformer.SetTransform(transformIJKtoRAS)
transformer.ReleaseDataFlagOn()
transformer.Update()
normals = vtk.vtkPolyDataNormals()
normals.ComputePointNormalsOn()
normals.SetInputData(transformer.GetOutput())
normals.SetFeatureAngle(60)
normals.SetSplitting(1)
normals.ReleaseDataFlagOn()
normals.Update()
stripper = vtk.vtkStripper()
stripper.SetInputData(normals.GetOutput())
stripper.ReleaseDataFlagOff()
stripper.Update()
stripper.GetOutput()
result = vtk.vtkPolyData()
result.DeepCopy(stripper.GetOutput())
return result
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkSphereSource()
#source = vtk.vtkConeSource()
source.Update()
polydata = vtk.vtkPolyData()
polydata.SetPoints(source.GetOutput().GetPoints())
# Construct the surface the create isosurface
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volumn whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent, vetReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reverse.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkSphereSource()
#source = vtk.vtkConeSource()
source.Update()
polydata = vtk.vtkPolyData()
polydata.SetPoints(source.GetOutput().GetPoints())
# Construct the surface the create isosurface
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volumn whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent, vetReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reverse.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def createSurface(self, points):
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputConnection(points.GetOutputPort())
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
return reverse
def to_vtk_files():
reader = vtk.vtkXMLUnstructuredGridReader()
writer = vtk.vtkXMLUnstructuredGridWriter()
for i in range(77):
reader.SetFileName('proteus_vtu/proteus_{}.vtu'.format(i))
reader.Update()
grid = reader.GetOutput()
# Extract boundaries
boundaries_filter = vtk.vtkGeometryFilter()
boundaries_filter.SetInputData(grid)
# boundaries_filter.ComputeNormalsOff()
# boundaries_filter.ComputeGradientsOff()
# boundaries_filter.ComputeScalarsOff()
# boundaries_filter.GenerateTrianglesOn()
boundaries_filter.Update()
boundaries = boundaries_filter.GetOutput()
# Reverse cells indexing (for reversing the normals)
reverse_normals = vtk.vtkReverseSense()
reverse_normals.ReverseCellsOn()
reverse_normals.ReverseNormalsOn()
reverse_normals.SetInputData(boundaries)
reverse_normals.Update()
reversed_normals = reverse_normals.GetOutput()
# Compute the cell normals (this is needed otherwise ReverseSense seems
# to compute point normals)
# compute_cell_normals = vtk.vtkPolyDataNormals()
# compute_cell_normals.ComputePointNormalsOff() # Flat shading in shaders
# compute_cell_normals.ComputeCellNormalsOn()
# compute_cell_normals.SetInputData(reversed_normals)
# computed_cell_normals = compute_cell_normals.GetOutput()
# Extract the unstructured grid
ugrid_filter = vtk.vtkAppendFilter()
ugrid_filter.SetInputData(reversed_normals)
ugrid_filter.Update()
unstructured_grid = ugrid_filter.GetOutput()
writer.SetInputData(unstructured_grid)
writer.SetFileName('proteus_vtu/proteus_boundaries_{}.vtu'.format(i))
writer.Write()
def vtkImportSTLfile(self, path):
""" Importation d'un fichier stl """
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName(path)
stlReader.Update()
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(stlReader.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
self.meshMapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
self.meshMapper.SetInput(reverse.GetOutput())
else:
self.meshMapper.SetInputConnection(reverse.GetOutputPort())
self.vtkPlotSTLMesh()
def MakeGlyphs(src, reverseNormals):
'''
Glyph the normals on the surface.
You may need to adjust the parameters for maskPts, arrow and glyph for a
nice appearance.
:param: src - the surface to glyph.
:param: reverseNormals - if True the normals on the surface are reversed.
:return: The glyph object.
'''
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
# Choose a random subset of points.
maskPts = vtk.vtkMaskPoints()
maskPts.SetOnRatio(5)
maskPts.RandomModeOn()
if reverseNormals:
reverse.SetInputData(src)
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
maskPts.SetInputConnection(reverse.GetOutputPort())
else:
maskPts.SetInputData(src)
# Source for the glyph filter
arrow = vtk.vtkArrowSource()
arrow.SetTipResolution(16)
arrow.SetTipLength(0.3)
arrow.SetTipRadius(0.1)
glyph = vtk.vtkGlyph3D()
glyph.SetSourceConnection(arrow.GetOutputPort())
glyph.SetInputConnection(maskPts.GetOutputPort())
glyph.SetVectorModeToUseNormal()
glyph.SetScaleFactor(1)
glyph.SetColorModeToColorByVector()
glyph.SetScaleModeToScaleByVector()
glyph.OrientOn()
glyph.Update()
return glyph
def MakeGlyphs(src, reverseNormals):
'''
Glyph the normals on the surface.
You may need to adjust the parameters for maskPts, arrow and glyph for a
nice appearance.
:param: src - the surface to glyph.
:param: reverseNormals - if True the normals on the surface are reversed.
:return: The glyph object.
'''
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
# Choose a random subset of points.
maskPts = vtk.vtkMaskPoints()
maskPts.SetOnRatio(5)
maskPts.RandomModeOn()
if reverseNormals:
reverse.SetInputData(src)
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
maskPts.SetInputConnection(reverse.GetOutputPort())
else:
maskPts.SetInputData(src)
# Source for the glyph filter
arrow = vtk.vtkArrowSource()
arrow.SetTipResolution(16)
arrow.SetTipLength(0.3)
arrow.SetTipRadius(0.1)
glyph = vtk.vtkGlyph3D()
glyph.SetSourceConnection(arrow.GetOutputPort())
glyph.SetInputConnection(maskPts.GetOutputPort())
glyph.SetVectorModeToUseNormal()
glyph.SetScaleFactor(1)
glyph.SetColorModeToColorByVector()
glyph.SetScaleModeToScaleByVector()
glyph.OrientOn()
glyph.Update()
return glyph
def vtkCreateSTLMesh(self):
""" Affichage d'un fichier mesh STL"""
self.meshMapper = vtk.vtkReverseSense()
#~ self.meshMapper.SetInputConnection(self.meshNormals.GetOutputPort())
self.meshMapper.ReverseCellsOn()
self.meshMapper.ReverseNormalsOn()
self.STLMeshMapper = vtk.vtkPolyDataMapper()
self.STLMeshMapper.SetInputConnection(self.meshMapper.GetOutputPort())
self.meshNormals = vtk.vtkPolyDataNormals()
self.meshNormals.SetInputConnection(self.STLMeshMapper.GetOutputPort())
self.meshNormals.SetFeatureAngle(60.0)
self.meshNormals.ComputeCellNormalsOn()
self.meshNormals.ComputePointNormalsOn()
self.meshNormals.ConsistencyOn()
self.meshNormals.AutoOrientNormalsOn()
def marchingCubes(volume) -> pv.PolyData:
# use marching cube algorithm
cf = vtk.vtkMarchingCubes()
cf.SetInputData(volume)
cf.SetValue(0, 1)
cf.Update()
# reverse the normal
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
mesh = reverse.GetOutput()
mesh = pv.wrap(mesh)
return mesh
def surfaceRecon(vtkPolyData):
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputData(vtkPolyData)
print(surf)
contour = vtk.vtkContourFilter()
contour.SetInputConnection(surf.GetOutputPort())
contour.SetValue(0, 0.0)
print(contour)
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contour.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInputConnection(reverse.GetOutputPort())
contourMapper.ScalarVisibilityOff()
print(contourMapper)
contourActor = vtk.vtkActor()
contourActor.SetMapper(contourMapper)
print(contourActor)
return contourActor
def reverse_sense_and_normals(vtk_algorithm_output):
"""
Sometimes the contouring algorithm can create a volume whose gradient
vector and ordering of polygon (using the right hand rule) are
inconsistent. vtkReverseSense cures this problem.
Args:
vtk_algorithm_output (vtkAlgorithmOutput): output of a VTK algorithm,
to get with: algorithm_instance.GetOutputPort()
Returns:
surface with reversed normals (vtk.vtkPolyData)
"""
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(vtk_algorithm_output)
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
return reverse.GetOutput()
def transform(inputModel, outputModel, scaleX=1.0, scaleY=1.0, scaleZ=1.0, translateX=0.0, translateY=0.0, translateZ=0.0):
"""Mesh relaxation based on vtkWindowedSincPolyDataFilter.
Scale of 1.0 means original size, >1.0 means magnification.
"""
transform = vtk.vtkTransform()
transform.Translate(translateX, translateY, translateZ)
transform.Scale(scaleX, scaleY, scaleZ)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(inputModel.GetPolyData())
transformFilter.SetTransform(transform)
if transform.GetMatrix().Determinant() >= 0.0:
transformFilter.Update()
outputModel.SetAndObservePolyData(transformFilter.GetOutput())
else:
# The mesh is turned inside out, reverse the mesh cells to keep them facing outside
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(transformFilter.GetOutputPort())
reverse.Update()
outputModel.SetAndObservePolyData(reverse.GetOutput())
def threshold(self, value=None, flip=False):
"""
Create a polygonal Mesh from a Picture by filling regions with pixels
luminosity above a specified value.
Parameters
----------
value : float, optional
The default is None, e.i. 1/3 of the scalar range.
flip: bool, optional
Flip polygon orientations
Returns
-------
Mesh
A polygonal mesh.
"""
mgf = vtk.vtkImageMagnitude()
mgf.SetInputData(self._data)
mgf.Update()
msq = vtk.vtkMarchingSquares()
msq.SetInputData(mgf.GetOutput())
if value is None:
r0, r1 = self._data.GetScalarRange()
value = r0 + (r1 - r0) / 3
msq.SetValue(0, value)
msq.Update()
if flip:
rs = vtk.vtkReverseSense()
rs.SetInputData(msq.GetOutput())
rs.ReverseCellsOn()
rs.ReverseNormalsOff()
rs.Update()
output = rs.GetOutput()
else:
output = msq.GetOutput()
ctr = vtk.vtkContourTriangulator()
ctr.SetInputData(output)
ctr.Update()
return vedo.Mesh(ctr.GetOutput(), c='k').bc('t').lighting('off')
def createPlaneModel(self, InputModel, plane, breastFlag):
#this function creates a model (visual representation) of the defined plane
#The input is linearly extruded to create a closed input model so that when the cutter extracts the
# region it is large enough to create a plane to cover the entire breast
closedInputModel = vtk.vtkLinearExtrusionFilter()
closedInputModel.SetInputData(InputModel)
closedInputModel.SetScaleFactor(100)
closedInputModel.CappingOn()
closedInputModel.Update()
clippedInput = vtk.vtkClipPolyData()
clippedInput.SetInputData(closedInputModel.GetOutput())
clippedInput.SetClipFunction(plane)
clippedInput.SetValue(0)
clippedInput.SetInsideOut(breastFlag)
clippedInput.Update()
cutterPlane = vtk.vtkCutter()
cutterPlane.SetCutFunction(plane)
cutterPlane.SetInputData(clippedInput.GetOutput())
cutterPlane.Update()
cutterModel = vtk.vtkPolyData()
cutterModel = cutterPlane.GetOutput()
surfPlane = vtk.vtkSurfaceReconstructionFilter()
surfPlane.SetInputData(cutterModel)
surfPlane.SetSampleSpacing(2.5)
cfPlane = vtk.vtkContourFilter()
cfPlane.SetInputConnection(surfPlane.GetOutputPort())
cfPlane.SetValue(0, 0.0)
reversePlane = vtk.vtkReverseSense()
reversePlane.SetInputConnection(cfPlane.GetOutputPort())
reversePlane.ReverseCellsOn()
reversePlane.ReverseNormalsOn()
return reversePlane
def vertices_to_surface(vertices, num_simplify_iter=3, smooth=True):
polydata = mesh_to_polydata(vertices, [])
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetNeighborhoodSize(30)
surf.SetSampleSpacing(5)
surf.SetInputData(polydata)
surf.Update()
# Visualize signed distance function computed by VTK (VTK bug: error outside actual contour)
# q = surf.GetOutput()
# arr = numpy_support.vtk_to_numpy(q.GetPointData().GetScalars())
# sc = arr.reshape(q.GetDimensions()[::-1])
# plt.imshow(sc[40,:,:]);
# plt.colorbar();
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.)
# print cf.GetNumberOfContours()
cf.Update()
# polydata = cf.GetOutput()
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
polydata = reverse.GetOutput()
polydata = simplify_polydata(polydata,
num_simplify_iter=num_simplify_iter,
smooth=smooth)
return polydata
cowReader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/Viewpoint/cow.obj")
plane = vtk.vtkPlane()
plane.SetNormal(1, 0, 0)
cowClipper = vtk.vtkClipPolyData()
cowClipper.SetInputConnection(cowReader.GetOutputPort())
cowClipper.SetClipFunction(plane)
cellNormals = vtk.vtkPolyDataNormals()
cellNormals.SetInputConnection(cowClipper.GetOutputPort())
cellNormals.ComputePointNormalsOn()
cellNormals.ComputeCellNormalsOn()
reflect = vtk.vtkTransform()
reflect.Scale(-1, 1, 1)
cowReflect = vtk.vtkTransformPolyDataFilter()
cowReflect.SetTransform(reflect)
cowReflect.SetInputConnection(cellNormals.GetOutputPort())
cowReverse = vtk.vtkReverseSense()
cowReverse.SetInputConnection(cowReflect.GetOutputPort())
cowReverse.ReverseNormalsOn()
cowReverse.ReverseCellsOff()
reflectedMapper = vtk.vtkPolyDataMapper()
reflectedMapper.SetInputConnection(cowReverse.GetOutputPort())
reflected = vtk.vtkActor()
reflected.SetMapper(reflectedMapper)
reflected.GetProperty().SetDiffuseColor(flesh)
reflected.GetProperty().SetDiffuse(.8)
reflected.GetProperty().SetSpecular(.5)
reflected.GetProperty().SetSpecularPower(30)
reflected.GetProperty().FrontfaceCullingOn()
ren1.AddActor(reflected)
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cowClipper.GetOutputPort())
def addCSVFile(self,fname,csvDelimiter=None):
self.setCaption(r' File:'+str(fname))
pts=np.loadtxt(fname,csvDelimiter)
r,t,z = rec2cyl(pts[:,0],pts[:,1],pts[:,2])
sf=self.scalingFactor
if pts.shape[1] == 4:
im=pts[:,3]
else:
im=getGeomImperfection(r,z,np.mean(r))
rid=r-im
xx,yy,zz=cyl2rec(rid+im*sf,t,z)
points = vtk.vtkPoints()
colors =vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
for i in range(0,pts.shape[0]):
points.InsertPoint(i,xx[i],yy[i],zz[i] )
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.GetPointData().SetScalars(colors)
polydata.Update()
surf =vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
surf.SetNeighborhoodSize(self.nbSize)
surf.SetSampleSpacing(self.sampleSpacing)
contourFilter = vtk.vtkContourFilter()
contourFilter.SetInputConnection(surf.GetOutputPort())
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contourFilter.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
outputPolyData=reverse.GetOutput()
newSurf = self.transform_back( points, reverse.GetOutput());
pts2=np.zeros((newSurf.GetNumberOfPoints(),3))
for i in range(0,newSurf.GetNumberOfPoints()):
pts2[i,:]=newSurf.GetPoint(i)
r2,t2,z2 = rec2cyl(pts2[:,0],pts2[:,1],pts2[:,2])
im2=getGeomImperfection(r2,z2,np.mean(r2))
self.paint.setValue(np.min(im2))
self.paint.setValue(np.max(im2))
for i in range(0,newSurf.GetNumberOfPoints()):
colors.InsertNextTupleValue(self.paint.getRGB(im2[i]))
newSurf.GetPointData().SetScalars(colors );
self.outputs.append(newSurf)
mapper = vtk.vtkPolyDataMapper();
mapper.InterpolateScalarsBeforeMappingOn()
mapper.SetInputConnection(newSurf.GetProducerPort())
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn();
surfaceActor = vtk.vtkActor();
surfaceActor.SetMapper(mapper);
self.ren.AddActor(surfaceActor);
def addCSVFile(self,fname,mode='folded',csvDelimiter=None):
self.setCaption(r' File:'+str(fname))
pts=np.loadtxt(fname,csvDelimiter)
points = vtk.vtkPoints()
r,t,z = rec2cyl(pts[:,0],pts[:,1],pts[:,2])
im_g=getGeomImperfection(r,z,np.mean(r))
if pts.shape[1] == 4:
useThickImp=True
else:
useThickImp=False
if useThickImp:
im_t=pts[:,3]
else:
im_t=np.zeros(pts.shape[0])
rid=r-im_g
if mode == 'unfolded':
tt=t*r.mean()
rr=im_g*self.scalingFactor
for i in range(0,pts.shape[0]):
points.InsertPoint(i,tt[i],z[i],rr[i] )
else:
xx,yy,zz=cyl2rec(rid+im_g*self.scalingFactor,t,z)
for i in range(0,pts.shape[0]):
points.InsertPoint(i,xx[i],yy[i],zz[i] )
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.Update()
if useThickImp:
imps=im_t
else:
imps=im_g
# imps=vtk.vtkFloatArray()
# if useThickImp:
# for i in range(0,polydata.GetNumberOfPoints()):
# imps.InsertNextValue(im_t[i])
# else:
# imps.InsertNextValue(im_g[i])
# polydata.GetPointData().SetScalars(imps);
#
surf =vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
surf.SetNeighborhoodSize(self.nbSize)
surf.SetSampleSpacing(self.sampleSpacing)
contourFilter = vtk.vtkContourFilter()
contourFilter.SetInputConnection(surf.GetOutputPort())
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contourFilter.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
outputPolyData=reverse.GetOutput()
newSurf = self.transform_back( points, reverse.GetOutput());
pts2=np.zeros((newSurf.GetNumberOfPoints(),3))
for i in range(0,newSurf.GetNumberOfPoints()):
pts2[i,:]=newSurf.GetPoint(i)
r2,t2,z2 = rec2cyl(pts2[:,0],pts2[:,1],pts2[:,2])
kDTree = vtk.vtkKdTreePointLocator()
kDTree.SetDataSet(polydata)
kDTree.BuildLocator()
colors=vtk.vtkFloatArray()
for i in range(0,len(pts2)):
kid=kDTree.FindClosestPoint(pts2[i])
colors.InsertNextValue(imps[kid])
# if mode == 'folded':
# im2=getGeomImperfection(r2,z2,np.mean(r2))/self.scalingFactor
#
# if mode == 'unfolded':
# im2=pts2[:,2]/self.scalingFactor
#
# colors=vtk.vtkFloatArray()
# for i in range(0,newSurf.GetNumberOfPoints()):
# colors.InsertNextValue(im2[i])
newSurf.GetPointData().SetScalars(colors);
self.scalarRange=colors.GetRange()
self.lut=vtk.vtkLookupTable()
self.lut.SetNumberOfTableValues(100)
self.lut.SetTableRange(self.scalarRange)
self.lut.SetHueRange(0.667, 0.0)
self.lut.Build()
self.resP=newSurf.GetProducerPort()
self.colors=colors
self.outputs.append(newSurf)
mapper = vtk.vtkPolyDataMapper();
mapper.SetLookupTable(self.lut)
mapper.InterpolateScalarsBeforeMappingOn()
mapper.SetInputConnection(newSurf.GetProducerPort())
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn();
mapper.SetScalarRange(colors.GetRange())
surfaceActor = vtk.vtkActor();
surfaceActor.SetMapper(mapper);
self.boundBox=newSurf.GetBounds()
self.ren.AddActor(surfaceActor);
def updateModelFromMarkup(self, inputMarkup, outputModel):
"""
Update model to enclose all points in the input markup list
"""
# Delaunay triangulation is robust and creates nice smooth surfaces from a small number of points,
# however it can only generate convex surfaces robustly.
useDelaunay = True
# Create polydata point set from markup points
points = vtk.vtkPoints()
cellArray = vtk.vtkCellArray()
numberOfPoints = inputMarkup.GetNumberOfFiducials()
# Surface generation algorithms behave unpredictably when there are not enough points
# return if there are very few points
if useDelaunay:
if numberOfPoints < 3:
return
else:
if numberOfPoints < 10:
return
points.SetNumberOfPoints(numberOfPoints)
new_coord = [0.0, 0.0, 0.0]
for i in range(numberOfPoints):
inputMarkup.GetNthFiducialPosition(i, new_coord)
points.SetPoint(i, new_coord)
cellArray.InsertNextCell(numberOfPoints)
for i in range(numberOfPoints):
cellArray.InsertCellPoint(i)
pointPolyData = vtk.vtkPolyData()
pointPolyData.SetLines(cellArray)
pointPolyData.SetPoints(points)
# Create surface from point set
if useDelaunay:
delaunay = vtk.vtkDelaunay3D()
delaunay.SetInputData(pointPolyData)
surfaceFilter = vtk.vtkDataSetSurfaceFilter()
surfaceFilter.SetInputConnection(delaunay.GetOutputPort())
smoother = vtk.vtkButterflySubdivisionFilter()
smoother.SetInputConnection(surfaceFilter.GetOutputPort())
smoother.SetNumberOfSubdivisions(3)
smoother.Update()
outputModel.SetPolyDataConnection(smoother.GetOutputPort())
else:
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputData(pointPolyData)
surf.SetNeighborhoodSize(20)
surf.SetSampleSpacing(
80
) # lower value follows the small details more closely but more dense pointset is needed as input
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOff()
reverse.ReverseNormalsOff()
outputModel.SetPolyDataConnection(reverse.GetOutputPort())
# Create default model display node if does not exist yet
if not outputModel.GetDisplayNode():
modelDisplayNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLModelDisplayNode")
# Get color of edited segment
segmentationNode = self.scriptedEffect.parameterSetNode(
).GetSegmentationNode()
segmentID = self.scriptedEffect.parameterSetNode(
).GetSelectedSegmentID()
r, g, b = segmentationNode.GetSegmentation().GetSegment(
segmentID).GetColor()
modelDisplayNode.SetColor(r, g, b) # Edited segment color
modelDisplayNode.BackfaceCullingOff()
modelDisplayNode.SliceIntersectionVisibilityOn()
modelDisplayNode.SetSliceIntersectionThickness(2)
modelDisplayNode.SetOpacity(0.3) # Between 0-1, 1 being opaque
slicer.mrmlScene.AddNode(modelDisplayNode)
outputModel.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
outputModel.GetDisplayNode().SliceIntersectionVisibilityOn()
outputModel.Modified()
def 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.SetAutoOrientNormals(state.autoOrientNormals)
normals.SetFlipNormals(state.flipNormals)
normals.SetSplitting(state.splitting)
normals.SetFeatureAngle(state.featureAngle)
normals.ConsistencyOn()
normals.SetInputConnection(surface)
surface = normals.GetOutputPort()
if state.mirror:
mirrorTransformMatrix = vtk.vtkMatrix4x4()
mirrorTransformMatrix.SetElement(0, 0, -1 if state.mirrorX else 1)
mirrorTransformMatrix.SetElement(1, 1, -1 if state.mirrorY else 1)
mirrorTransformMatrix.SetElement(2, 2, -1 if state.mirrorZ else 1)
mirrorTransform = vtk.vtkTransform()
mirrorTransform.SetMatrix(mirrorTransformMatrix)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(surface)
transformFilter.SetTransform(mirrorTransform)
surface = transformFilter.GetOutputPort()
if mirrorTransformMatrix.Determinant() < 0:
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(surface)
surface = reverse.GetOutputPort()
if state.cleaner:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(surface)
surface = cleaner.GetOutputPort()
if state.fillHoles:
fillHoles = vtk.vtkFillHolesFilter()
fillHoles.SetHoleSize(state.fillHolesSize)
fillHoles.SetInputConnection(surface)
# Need to auto-orient normals, otherwise holes
# could appear to be unfilled when only front-facing elements
# are chosen to be visible.
normals = vtk.vtkPolyDataNormals()
normals.AutoOrientNormalsOn()
normals.ConsistencyOn()
normals.SetInputConnection(fillHoles.GetOutputPort())
surface = normals.GetOutputPort()
if state.connectivity:
connectivity = vtk.vtkPolyDataConnectivityFilter()
connectivity.SetExtractionModeToLargestRegion()
connectivity.SetInputConnection(surface)
surface = connectivity.GetOutputPort()
state.outputModelNode.SetPolyDataConnection(surface)
return True
print('texture test')
assert isinstance(st.GetTexture(), vtk.vtkTexture)
###################################### deletePoints
sd = sphere.clone().deletePoints(range(100))
print('deletePoints', sd.N(), sphere.N())
assert sd.N() == sphere.N()
print('deletePoints', sd.NCells(), '<', sphere.NCells())
assert sd.NCells() < sphere.NCells()
###################################### reverse
# this fails on some archs (see issue #185)
# lets comment it out temporarily
sr = sphere.clone().reverse().cutWithPlane()
print('DISABLED: reverse test', sr.N(), 576)
rev = vtk.vtkReverseSense()
rev.SetInputData(sr.polydata())
rev.Update()
print(rev.GetOutput())
print('DISABLED: reverse vtk nr.pts, nr.cells')
print(
rev.GetOutput().GetNumberOfPoints(),
sr.polydata().GetNumberOfPoints(),
rev.GetOutput().GetNumberOfCells(),
sr.polydata().GetNumberOfCells(),
)
# assert sr.N() == 576
###################################### quantize
sq = sphere.clone().quantize(0.1)
print('quantize', sq.N(), 834)
def reconstructSurface(folder):
pointSource = vtk.vtkProgrammableSource()
def readPoints():
output = pointSource.GetPolyDataOutput()
points = vtk.vtkPoints()
output.SetPoints(points)
group_points = groupsToPoints(folder)
for p in group_points:
points.insertNextPoint(p[0],p[1],p[2])
pointSource.SetExecuteMethod(readPoints)
# Construct the surface and create isosurface.
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputConnection(pointSource.GetOutputPort())
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
map = vtk.vtkPolyDataMapper()
map.SetInputConnection(reverse.GetOutputPort())
map.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(map)
surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
surfaceActor.GetProperty().SetSpecularColor(1, 1, 1)
surfaceActor.GetProperty().SetSpecular(.4)
surfaceActor.GetProperty().SetSpecularPower(50)
# Create the RenderWindow, Renderer and both Actors
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
ren.AddActor(surfaceActor)
ren.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
ren.GetActiveCamera().SetPosition(1, 0, 0)
ren.GetActiveCamera().SetViewUp(0, 0, 1)
ren.ResetCamera()
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Elevation(30)
ren.GetActiveCamera().Dolly(1.2)
ren.ResetCameraClippingRange()
iren.Initialize()
renWin.Render()
iren.Start()
def testReconstructSurface(self):
# Read some points. Use a programmable filter to read them.
#
pointSource = vtk.vtkProgrammableSource()
def readPoints():
fp = open(VTK_DATA_ROOT + "/Data/cactus.3337.pts", "r")
points = vtk.vtkPoints()
while True:
line = fp.readline().split()
if len(line) == 0:
break
if line[0] == "p":
points.InsertNextPoint(float(line[1]), float(line[2]), float(line[3]))
pointSource.GetPolyDataOutput().SetPoints(points)
pointSource.SetExecuteMethod(readPoints)
# Construct the surface and create isosurface
#
surf = vtk.vtkSurfaceReconstructionFilter()
surf.SetInputConnection(pointSource.GetOutputPort())
cf = vtk.vtkContourFilter()
cf.SetInputConnection(surf.GetOutputPort())
cf.SetValue(0, 0.0)
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(cf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
map = vtk.vtkPolyDataMapper()
map.SetInputConnection(reverse.GetOutputPort())
map.ScalarVisibilityOff()
surfaceActor = vtk.vtkActor()
surfaceActor.SetMapper(map)
surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
surfaceActor.GetProperty().SetSpecularColor(1, 1, 1)
surfaceActor.GetProperty().SetSpecular(.4)
surfaceActor.GetProperty().SetSpecularPower(50)
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(surfaceActor)
ren.SetBackground(1, 1, 1)
renWin.SetSize(300, 300)
ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
ren.GetActiveCamera().SetPosition(1, 0, 0)
ren.GetActiveCamera().SetViewUp(0, 0, 1)
ren.ResetCamera()
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Elevation(30)
ren.GetActiveCamera().Dolly(1.2)
ren.ResetCameraClippingRange()
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "reconstructSurface.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
points.InsertNextPoint(x, y, x*y+x) pointSource.SetExecuteMethod(readPoints) # Construct the surface and create isosurface. surf = vtk.vtkSurfaceReconstructionFilter() surf.SetInputConnection(pointSource.GetOutputPort()) cf = vtk.vtkContourFilter() cf.SetInputConnection(surf.GetOutputPort()) cf.SetValue(0, 0.0) # Sometimes the contouring algorithm can create a volume whose gradient # vector and ordering of polygon (using the right hand rule) are # inconsistent. vtkReverseSense cures this problem. reverse = vtk.vtkReverseSense() reverse.SetInputConnection(cf.GetOutputPort()) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() map = vtk.vtkPolyDataMapper() map.SetInputConnection(reverse.GetOutputPort()) map.ScalarVisibilityOff() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(map) surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) surfaceActor.GetProperty().SetSpecularColor(1, 1, 1) surfaceActor.GetProperty().SetSpecular(.4) surfaceActor.GetProperty().SetSpecularPower(50)
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.SetAutoOrientNormals(state.autoOrientNormals)
normals.SetFlipNormals(state.flipNormals)
normals.SetSplitting(state.splitting)
normals.SetFeatureAngle(state.featureAngle)
normals.ConsistencyOn()
normals.SetInputConnection(surface)
surface = normals.GetOutputPort()
if state.mirror:
mirrorTransformMatrix = vtk.vtkMatrix4x4()
mirrorTransformMatrix.SetElement(0, 0, -1 if state.mirrorX else 1)
mirrorTransformMatrix.SetElement(1, 1, -1 if state.mirrorY else 1)
mirrorTransformMatrix.SetElement(2, 2, -1 if state.mirrorZ else 1)
mirrorTransform = vtk.vtkTransform()
mirrorTransform.SetMatrix(mirrorTransformMatrix)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(surface)
transformFilter.SetTransform(mirrorTransform)
surface = transformFilter.GetOutputPort()
if mirrorTransformMatrix.Determinant()<0:
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(surface)
surface = reverse.GetOutputPort()
if state.cleaner:
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(surface)
surface = cleaner.GetOutputPort()
if state.fillHoles:
fillHoles = vtk.vtkFillHolesFilter()
fillHoles.SetHoleSize(state.fillHolesSize)
fillHoles.SetInputConnection(surface)
# Need to auto-orient normals, otherwise holes
# could appear to be unfilled when only front-facing elements
# are chosen to be visible.
normals = vtk.vtkPolyDataNormals()
normals.AutoOrientNormalsOn()
normals.ConsistencyOn()
normals.SetInputConnection(fillHoles.GetOutputPort())
surface = normals.GetOutputPort()
if state.connectivity:
connectivity = vtk.vtkPolyDataConnectivityFilter()
connectivity.SetExtractionModeToLargestRegion()
connectivity.SetInputConnection(surface)
surface = connectivity.GetOutputPort()
state.outputModelNode.SetPolyDataConnection(surface)
return True
def myMain(controller,args):
fname=args.fname
controller=args.controller
myid = controller.GetLocalProcessId();
numProcs = controller.GetNumberOfProcesses();
pts=np.loadtxt(fname)
sf=100
paint=rgbPainter()
r,t,z = rec2cyl(pts[:,0],pts[:,1],pts[:,2])
#im=np.abs(getGeomImperfection(r,z,np.mean(r)))
if pts.shape[1] == 4:
im=pts[:,3]
else:
im=getGeomImperfection(r,z,np.mean(r))
rid=r-im
xx,yy,zz=cyl2rec(rid+im*sf,t,z)
math = vtk.vtkMath()
points = vtk.vtkPoints()
colors =vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
for i in range(0,pts.shape[0]):
#points.InsertPoint(i,pts[i][0],pts[i][1],pts[i][2] )
points.InsertPoint(i,xx[i],yy[i],zz[i] )
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.GetPointData().SetScalars(colors)
polydata.Update()
surf =vtk.vtkSurfaceReconstructionFilter()
surf.SetInput(polydata)
surf.SetNeighborhoodSize(40)
#surf.SetSampleSpacing(6.0)
if (myid != 0):
controller.AddRMI(surf.Update,'',200)
controller.ProcessRMIs();
else:
contourFilter = vtk.vtkContourFilter()
contourFilter.SetInputConnection(surf.GetOutputPort())
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contourFilter.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
outputPolyData=reverse.GetOutput()
#for i in range(0,pts.shape[0]):
# dcolor=np.zeros(3)
# colorLookupTable.GetColor(im[i],dcolor)
# cc=dcolor*255.0
# colors.InsertNextTupleValue(cc)
#outputPolyData.GetPointData().SetScalars(polydata.GetPointData().GetScalars() );
newSurf = transform_back( points, reverse.GetOutput());
pts2=np.zeros((newSurf.GetNumberOfPoints(),3))
for i in range(0,newSurf.GetNumberOfPoints()):
pts2[i,:]=newSurf.GetPoint(i)
r2,t2,z2 = rec2cyl(pts2[:,0],pts2[:,1],pts2[:,2])
im2=getGeomImperfection(r2,z2,np.mean(r2))
#im2-=np.min(im2)
#im2=np.abs(im2)
paint.setValue(np.min(im2))
paint.setValue(np.max(im2))
for i in range(0,newSurf.GetNumberOfPoints()):
colors.InsertNextTupleValue(paint.getRGB(im2[i]))
newSurf.GetPointData().SetScalars(colors );
mapper = vtk.vtkPolyDataMapper();
mapper.InterpolateScalarsBeforeMappingOn()
#mapper.SetInputConnection(outputPolyData.GetProducerPort())
mapper.SetInputConnection(newSurf.GetProducerPort())
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn();
surfaceActor = vtk.vtkActor();
surfaceActor.SetMapper(mapper);
ren = vtk.vtkRenderer();
renWin = vtk.vtkRenderWindow();
renWin.AddRenderer(ren);
iren = vtk.vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
ren.AddActor(surfaceActor);
ren.SetBackground(1, 1, 1);
renWin.SetSize(800, 600);
prn=1000.
pc=-prn
plXY = vtk.vtkPlaneSource()
plXY.SetPoint1(prn,-prn,0)
plXY.SetPoint2(-prn,prn,0)
plXY.SetOrigin(pc,pc,0)
plXY.SetCenter(0,0,0)
plXYmap = vtk.vtkPolyDataMapper()
plXYmap.SetInput(plXY.GetOutput())
plXYact = vtk.vtkActor()
plXYact.SetMapper(plXYmap)
plXYact.GetProperty().SetOpacity(0.1)
plYZ = vtk.vtkPlaneSource()
plYZ.SetCenter(0,pc,pc)
plYZ.SetPoint1(0,prn,-prn)
plYZ.SetPoint2(0,-prn,prn)
plYZmap = vtk.vtkPolyDataMapper()
plYZmap.SetInput(plYZ.GetOutput())
plYZact = vtk.vtkActor()
plYZact.SetMapper(plYZmap)
plYZact.GetProperty().SetOpacity(0.1)
plZX = vtk.vtkPlaneSource()
plZX.SetCenter(pc,0,pc)
plZX.SetPoint1(prn,0,-prn)
plZX.SetPoint2(-prn,0,prn)
plZXmap = vtk.vtkPolyDataMapper()
plZXmap.SetInput(plZX.GetOutput())
plZXact = vtk.vtkActor()
plZXact.SetMapper(plZXmap)
plZXact.GetProperty().SetOpacity(0.1)
ren.AddActor(plXYact)
ren.AddActor(plYZact)
ren.AddActor(plZXact)
ax=vtk.vtkAxesActor()
ax.GetXAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetYAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ax.GetZAxisCaptionActor2D().GetProperty().SetColor(0,0,0)
ow=vtk.vtkOrientationMarkerWidget()
ow.SetOrientationMarker(ax)
ow.SetInteractor(iren)
ow.SetViewport( 0.0, 0.0, 0.4, 0.4 )
ow.SetEnabled( 1 )
ow.InteractiveOn()
lut=vtk.vtkLookupTable()
lut.SetHueRange( 0.66667, 0.0 )
lut.SetSaturationRange (1.0, 1.0)
lut.SetNumberOfColors(50)# len(self.plotables))
lut.SetTableRange(paint.getMinValue(),paint.getMaxValue())
lut.Build()
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
scalar_bar.SetTitle("Imperfection value");
scalar_bar.SetNumberOfLabels(11)
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
iren.Initialize();
renWin.Render();
iren.Start();