def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
smoothingFilter = None
if self.Method is 'taubin':
smoothingFilter = vtk.vtkWindowedSincPolyDataFilter()
smoothingFilter.SetInput(self.Surface)
smoothingFilter.SetNumberOfIterations(self.NumberOfIterations)
smoothingFilter.SetPassBand(self.PassBand)
smoothingFilter.SetBoundarySmoothing(self.BoundarySmoothing)
## smoothingFilter.NormalizeCoordinatesOn()
smoothingFilter.Update()
elif self.Method is 'laplace':
smoothingFilter = vtk.vtkSmoothPolyDataFilter()
smoothingFilter.SetInput(self.Surface)
smoothingFilter.SetNumberOfIterations(self.NumberOfIterations)
smoothingFilter.SetRelaxationFactor(self.RelaxationFactor)
smoothingFilter.Update()
else:
self.PrintError('Error: smoothing method not supported.')
self.Surface = smoothingFilter.GetOutput()
normals = vmtkscripts.vmtkSurfaceNormals()
normals.Surface = self.Surface
normals.Execute()
self.Surface = normals.Surface
if self.Surface.GetSource():
self.Surface.GetSource().UnRegisterAllOutputs()
def update_mask(self, src):
# Filter
cast_filter = vtk.vtkImageCast()
cast_filter.SetOutputScalarTypeToUnsignedInt()
cast_filter.SetInputData(src)
cast_filter.Update()
# Create mesh using marching cube
march = vtk.vtkDiscreteMarchingCubes()
march.ComputeNormalsOn()
march.ComputeGradientsOn()
for i, organ in enumerate(Settings.organs):
march.SetValue(i, Settings.labels[organ]['value'])
march.SetInputData(cast_filter.GetOutput())
march.Update()
# Filtrate the masks
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputConnection(march.GetOutputPort())
smooth.SetNumberOfIterations(15)
smooth.BoundarySmoothingOff()
smooth.FeatureEdgeSmoothingOff()
smooth.SetFeatureAngle(120.0)
smooth.SetPassBand(.001)
smooth.NonManifoldSmoothingOn()
smooth.NormalizeCoordinatesOn()
smooth.Update()
self.surface_mapper.SetInputConnection(smooth.GetOutputPort())
def smoothMesh(mesh, nIterations=10):
"""Smooth a mesh using VTK's WindowedSincPolyData filter."""
try:
t = time.perf_counter()
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetNumberOfIterations(nIterations)
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
smooth.SetInputData(mesh)
else:
smooth.SetInput(mesh)
smooth.Update()
print("Surface smoothed")
m2 = smooth.GetOutput()
print(" ", m2.GetNumberOfPolys(), "polygons")
elapsedTime(t)
smooth = None
return m2
except:
print("Surface smoothing 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 run(neuron_num):
file = "meshes-with-axons-filled-assembled/n%02d.vtp" % neuron_num
readerVolume = vtk.vtkXMLPolyDataReader()
readerVolume.SetFileName(file)
readerVolume.Update()
decimate = readerVolume
nlod = 5
for i in range(nlod):
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(decimate.GetOutputPort())
smoother.SetNumberOfIterations(20) # This has little effect on the error!
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetPassBand(.1) # This increases the error a lot! .001
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.GenerateErrorScalarsOn()
smoother.Update()
decimate = vtk.vtkQuadricDecimation ()
decimate.SetInputData(smoother.GetOutput())
decimate.SetTargetReduction(.7)
decimate.Update()
full_out_name = 'meshes-with-axons-filled-assembled-lod/n%02d_LOD%d.obj' % (neuron_num, i - 1)
writer = vtk.vtkOBJWriter()
writer.SetFileName(full_out_name)
writer.SetInputData(decimate.GetOutput())
writer.Write()
def windowed_sinc_smooth_vtk_polydata(poly,
iteration=15,
band=0.1,
boundary=False,
feature=False):
"""
This function smooths a vtk polydata, using windowed sinc algorithm
Args:
poly: vtk polydata to smooth
boundary: boundary smooth bool
Returns:
smoothed vtk polydata
"""
ftr = vtk.vtkWindowedSincPolyDataFilter()
ftr.SetInputData(poly)
ftr.SetNumberOfIterations(iteration)
ftr.SetPassBand(band)
ftr.SetBoundarySmoothing(boundary)
ftr.SetFeatureEdgeSmoothing(feature)
ftr.NonManifoldSmoothingOn()
ftr.NormalizeCoordinatesOn()
ftr.Update()
return ftr.GetOutput()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
smoothingFilter = None
if self.Method is 'taubin':
smoothingFilter = vtk.vtkWindowedSincPolyDataFilter()
smoothingFilter.SetInputData(self.Surface)
smoothingFilter.SetNumberOfIterations(self.NumberOfIterations)
smoothingFilter.SetPassBand(self.PassBand)
smoothingFilter.SetBoundarySmoothing(self.BoundarySmoothing)
smoothingFilter.SetNormalizeCoordinates(self.NormalizeCoordinates)
smoothingFilter.Update()
elif self.Method is 'laplace':
smoothingFilter = vtk.vtkSmoothPolyDataFilter()
smoothingFilter.SetInputData(self.Surface)
smoothingFilter.SetNumberOfIterations(self.NumberOfIterations)
smoothingFilter.SetRelaxationFactor(self.RelaxationFactor)
smoothingFilter.Update()
else:
self.PrintError('Error: smoothing method not supported.')
self.Surface = smoothingFilter.GetOutput()
normals = vmtkscripts.vmtkSurfaceNormals()
normals.Surface = self.Surface
normals.Execute()
self.Surface = normals.Surface
def smooth_surface(vtk_path, output_path):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(vtk_path)
reader.Update()
if (reader.GetOutput().GetNumberOfPoints() == 0):
print('WARNING: nothing to smooth for', vtk_path)
return
smoothingIterations = 50
passBand = 0.05
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(reader.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.SetPassBand(passBand)
smoother.Update()
decimate = vtk.vtkDecimatePro()
decimate.SetInputData(smoother.GetOutput())
decimate.SetTargetReduction(0.8)
decimate.PreserveTopologyOn()
decimate.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputData(decimate.GetOutput())
writer.SetFileTypeToASCII()
writer.SetFileName(output_path) # .stl
writer.Update()
def simplify_polydata(polydata, num_simplify_iter=0, smooth=False):
for simplify_iter in range(num_simplify_iter):
t = time.time()
deci = vtk.vtkQuadricDecimation()
deci.SetInputData(polydata)
deci.SetTargetReduction(0.8)
# 0.8 means each iteration causes the point number to drop to 20% the original
deci.Update()
polydata = deci.GetOutput()
if smooth:
smoother = vtk.vtkWindowedSincPolyDataFilter()
# smoother.NormalizeCoordinatesOn()
smoother.SetPassBand(.1)
smoother.SetNumberOfIterations(20)
smoother.SetInputData(polydata)
smoother.Update()
polydata = smoother.GetOutput()
n_pts = polydata.GetNumberOfPoints()
if polydata.GetNumberOfPoints() < 200:
break
sys.stderr.write('simplify %d @ %d: %.2f seconds\n' %
(simplify_iter, n_pts, time.time() - t)) #
return polydata
def create_mesh(label_pix, labels_to_use, inds_to_phys=None):
# convert the numpy representation to VTK, so we can create a mesh
# using marching cubes for display later
vtk_import = vtkImageImport()
vtk_import.SetImportVoidPointer(label_pix, True)
vtk_import.SetDataScalarType(VTK_UNSIGNED_CHAR)
vtk_import.SetNumberOfScalarComponents(1)
vtk_import.SetDataExtent(0, label_pix.shape[2] - 1, 0,
label_pix.shape[1] - 1, 0, label_pix.shape[0] - 1)
vtk_import.SetWholeExtent(0, label_pix.shape[2] - 1, 0,
label_pix.shape[1] - 1, 0,
label_pix.shape[0] - 1)
vtk_import.Update()
flipper = vtkImageFlip()
flipper.SetInputData(vtk_import.GetOutput())
flipper.SetFilteredAxis(1)
flipper.FlipAboutOriginOff()
flipper.Update()
vtk_img = flipper.GetOutput()
marching_cubes = vtkDiscreteMarchingCubes()
marching_cubes.SetInputData(vtk_img)
num_labels_to_use = len(labels_to_use)
marching_cubes.SetNumberOfContours(num_labels_to_use)
for i in range(num_labels_to_use):
marching_cubes.SetValue(i, labels_to_use[i])
marching_cubes.Update()
smoother = vtkWindowedSincPolyDataFilter()
smoother.SetInputData(marching_cubes.GetOutput())
smoother.SetNumberOfIterations(25)
smoother.SetPassBand(0.1)
smoother.SetBoundarySmoothing(False)
smoother.SetFeatureEdgeSmoothing(False)
smoother.SetFeatureAngle(120.0)
smoother.SetNonManifoldSmoothing(True)
smoother.NormalizeCoordinatesOn()
smoother.Update()
mesh_reduce = vtkQuadricDecimation()
mesh_reduce.SetInputData(smoother.GetOutput())
mesh_reduce.SetTargetReduction(0.25)
mesh_reduce.Update()
vertex_xform = np.mat(np.eye(4))
vertex_xform[1, 1] = -1
vertex_xform[1, 3] = label_pix.shape[1] + 1
vertex_xform = inds_to_phys * vertex_xform
return xform_mesh(mesh_reduce.GetOutput(), vertex_xform)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkWindowedSincPolyDataFilter(), 'Processing.',
('vtkPolyData',), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def createSTL(mha, stl):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(mha)
reader.Update()
threshold = vtk.vtkImageThreshold()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdByLower(0.1)
threshold.ReplaceInOn()
threshold.SetInValue(0) # set all values below 0.1 to 0
threshold.ReplaceOutOn()
threshold.SetOutValue(1) # set all values above 0.1 to 1
threshold.Update()
dmc = vtk.vtkFlyingEdges3D()
dmc.SetInputConnection(threshold.GetOutputPort())
dmc.ComputeNormalsOn()
dmc.GenerateValues(1, 1, 1)
dmc.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(dmc.GetOutputPort())
smoother.SetNumberOfIterations(15)
smoother.BoundarySmoothingOff()
smoother.Update()
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(smoother.GetOutputPort())
writer.SetFileTypeToBinary()
writer.SetFileName(stl)
writer.Write()
return 0
def extract_smooth_mesh(imageVTK,
label_range,
smoothing_iterations=30,
pass_band_param=0.01,
target_reduction=0.95):
'''Extract mesh/contour for labels in imageVTK, smooth and decimate.
Multiple labels can be extracted at once, however touching labels
will share vertices and the label ids are lost during smoothing/decimation.
Processing is slow for small objects in a large volume and should be cropped beforehand.
Args:
imageVTK: vtk image data
label_range: range of labels to extract. A tuple (l,l) will extract
a mesh for a single label id l
smoothing_iterations: number of iterations for vtkWindowedSincPolyDataFilter
pass_band_param: pass band param in range [0.,2.] for vtkWindowedSincPolyDataFilter.
Lower value remove higher frequencies.
target_reduction: target reduction for vtkQuadricDecimation
'''
n_contours = label_range[1] - label_range[0] + 1
# alternative vtkDiscreteMarchingCubes is slower and creates some weird missalignment lines when applied to tight crops
dfe = vtk.vtkDiscreteFlyingEdges3D()
dfe.SetInputData(imageVTK)
dfe.ComputeScalarsOff(
) # numpy image labels --> cells (faces) scalar values
dfe.ComputeNormalsOff()
dfe.ComputeGradientsOff()
dfe.InterpolateAttributesOff()
dfe.GenerateValues(n_contours, label_range[0],
label_range[1]) # numContours, rangeStart, rangeEnd
dfe.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(dfe.GetOutputPort())
smoother.SetNumberOfIterations(
smoothing_iterations) #this has little effect on the error!
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
# smoother.SetFeatureAngle(120)
smoother.SetPassBand(
pass_band_param) # from 0 to 2, 2 keeps high frequencies
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.GenerateErrorScalarsOff()
smoother.GenerateErrorVectorsOff()
smoother.Update()
# vtkQuadricDecimation looks cleaner than vtkDecimatePro (no unexpected sharp edges)
# but drop points scalar value --> can be added back if doing one instance a time
decimate = vtk.vtkQuadricDecimation()
decimate.SetInputConnection(smoother.GetOutputPort())
decimate.SetTargetReduction(target_reduction)
decimate.VolumePreservationOn()
decimate.Update()
return decimate.GetOutput()
def CreateFrogActor(fileName, tissue):
#reader = vtk.vtkMetaImageReader()
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(fileName)
reader.Update()
selectTissue = vtk.vtkImageThreshold()
#selectTissue.ThresholdBetween(tissue, tissue)
selectTissue.ThresholdBetween(120, 125)
selectTissue.SetInValue(255)
selectTissue.SetOutValue(0)
selectTissue.SetInputConnection(reader.GetOutputPort())
gaussianRadius = 1
gaussianStandardDeviation = 2.0
gaussian = vtk.vtkImageGaussianSmooth()
gaussian.SetStandardDeviations(gaussianStandardDeviation,
gaussianStandardDeviation,
gaussianStandardDeviation)
gaussian.SetRadiusFactors(gaussianRadius, gaussianRadius, gaussianRadius)
gaussian.SetInputConnection(selectTissue.GetOutputPort())
isoValue = 130
mcubes = vtk.vtkMarchingCubes()
#mcubes.SetInputConnection(gaussian.GetOutputPort())
mcubes.SetInputConnection(reader.GetOutputPort())
mcubes.ComputeScalarsOff()
mcubes.ComputeGradientsOff()
mcubes.ComputeNormalsOff()
mcubes.SetValue(0, isoValue)
smoothingIterations = 5
passBand = 0.001
featureAngle = 60.0
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(mcubes.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(featureAngle)
smoother.SetPassBand(passBand)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(smoother.GetOutputPort())
normals.SetFeatureAngle(featureAngle)
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(stripper.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def create_marching_cube(data,
color,
opacity=0.5,
min_threshold=0,
smoothing_iterations=None,
spacing=[1., 1., 1.]):
im = vtk.vtkImageData()
I, J, K = data.shape[:3]
im.SetDimensions(I, J, K)
im.SetSpacing(spacing[0], spacing[1], spacing[2])
im.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
vol = np.swapaxes(data, 0, 2)
vol = np.ascontiguousarray(vol)
vol = vol.ravel()
uchar_array = numpy_support.numpy_to_vtk(vol, deep=0)
im.GetPointData().SetScalars(uchar_array)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(im)
mapper.Update()
threshold = vtk.vtkImageThreshold()
threshold.SetInputData(im)
threshold.ThresholdByLower(min_threshold)
threshold.ReplaceInOn()
threshold.SetInValue(0)
threshold.ReplaceOutOn()
threshold.SetOutValue(1)
threshold.Update()
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInputConnection(threshold.GetOutputPort())
dmc.GenerateValues(1, 1, 1)
dmc.Update()
mapper = vtk.vtkPolyDataMapper()
if smoothing_iterations is not None:
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(dmc.GetOutputPort())
smoother.SetNumberOfIterations(smoothing_iterations)
smoother.Update()
mapper.SetInputConnection(smoother.GetOutputPort())
else:
mapper.SetInputConnection(dmc.GetOutputPort())
mapper.Update()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
mapper.ScalarVisibilityOff()
actor.GetProperty().SetColor(color)
actor.GetProperty().SetOpacity(opacity)
return actor
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkWindowedSincPolyDataFilter(),
'Processing.', ('vtkPolyData', ),
('vtkPolyData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def __init__(self, source):
# Get list with string-representations of the organs to be used
organs = Settings.organs
source.Update()
# Filter
cast_filter = vtk.vtkImageCast()
cast_filter.SetOutputScalarTypeToUnsignedInt()
cast_filter.SetInputConnection(source.GetOutputPort())
cast_filter.Update()
# Create mesh using marching cube
march = vtk.vtkDiscreteMarchingCubes()
march.ComputeNormalsOn()
march.ComputeGradientsOn()
for i, organ in enumerate(organs):
march.SetValue(i, Settings.labels[organ]['value'])
march.SetInputData(cast_filter.GetOutput())
march.Update()
# Filtrate the masks
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputConnection(march.GetOutputPort())
smooth.SetNumberOfIterations(15)
smooth.BoundarySmoothingOff()
smooth.FeatureEdgeSmoothingOff()
smooth.SetFeatureAngle(120.0)
smooth.SetPassBand(.001)
smooth.NonManifoldSmoothingOn()
smooth.NormalizeCoordinatesOn()
smooth.Update()
# Set lookup table
self.color_transfer = vtk.vtkDiscretizableColorTransferFunction()
self.alpha_transfer = vtk.vtkPiecewiseFunction()
self.color_transfer.AddRGBPoint(0, 0., 0., 0.) # Background
self.alpha_transfer.AddPoint(0, 0) # Background
for i, organ in enumerate(Settings.organs):
self.color_transfer.AddRGBPoint(Settings.labels[organ]['value'], *Settings.labels[organ]['rgb'])
self.alpha_transfer.AddPoint(Settings.labels[organ]['value'], 1.)
self.color_transfer.SetScalarOpacityFunction(self.alpha_transfer)
# Surface mapper
self.surface_mapper = vtk.vtkPolyDataMapper()
self.surface_mapper.SetLookupTable(self.color_transfer)
self.surface_mapper.SetInputConnection(smooth.GetOutputPort())
# Create the actor
self.actor = vtk.vtkActor()
self.actor.GetProperty().SetOpacity(1.)
self.actor.SetMapper(self.surface_mapper)
self.actor.GetProperty().ShadingOn()
def smoothen_mesh_vtkPolys(vtkPolys):
'''
apply mesh smoothing to a vtk mesh
'''
vtkSF=vtk.vtkWindowedSincPolyDataFilter()
vtkSF.SetNumberOfIterations(10)
vtkSF.SetInputData(vtkPolys)
vtkSF.Update()
return vtkSF.GetOutput()
def create_smooth_frog_actor(file_name, tissue):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(str(file_name))
reader.Update()
select_tissue = vtk.vtkImageThreshold()
select_tissue.ThresholdBetween(tissue, tissue)
select_tissue.SetInValue(255)
select_tissue.SetOutValue(0)
select_tissue.SetInputConnection(reader.GetOutputPort())
gaussianRadius = 1
gaussianStandardDeviation = 2.0
gaussian = vtk.vtkImageGaussianSmooth()
gaussian.SetStandardDeviations(gaussianStandardDeviation,
gaussianStandardDeviation,
gaussianStandardDeviation)
gaussian.SetRadiusFactors(gaussianRadius, gaussianRadius, gaussianRadius)
gaussian.SetInputConnection(select_tissue.GetOutputPort())
isoValue = 63.5
iso_surface = vtk.vtkFlyingEdges3D()
iso_surface.SetInputConnection(gaussian.GetOutputPort())
iso_surface.ComputeScalarsOff()
iso_surface.ComputeGradientsOff()
iso_surface.ComputeNormalsOff()
iso_surface.SetValue(0, isoValue)
smoothing_iterations = 20
pass_band = 0.001
feature_angle = 60.0
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(iso_surface.GetOutputPort())
smoother.SetNumberOfIterations(smoothing_iterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(feature_angle)
smoother.SetPassBand(pass_band)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOff()
smoother.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(smoother.GetOutputPort())
normals.SetFeatureAngle(feature_angle)
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(stripper.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def smooth_window(self, number_of_iterations=15, pass_band=0.5):
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputConnection(self.mesh.GetOutputPort())
smooth.SetNumberOfIterations(number_of_iterations)
smooth.BoundarySmoothingOn()
smooth.FeatureEdgeSmoothingOff()
smooth.SetPassBand(pass_band)
smooth.NonManifoldSmoothingOn()
smooth.NormalizeCoordinatesOn()
smooth.Update()
self.mesh = smooth
def _smoothPolydata(polydata, smoothingFactor):
passBand = pow(10.0, -4.0 * smoothingFactor)
smootherSinc = vtk.vtkWindowedSincPolyDataFilter()
smootherSinc.SetInputData(polydata)
smootherSinc.SetNumberOfIterations(20)
smootherSinc.FeatureEdgeSmoothingOff()
smootherSinc.BoundarySmoothingOff()
smootherSinc.NonManifoldSmoothingOn()
smootherSinc.NormalizeCoordinatesOn()
smootherSinc.Update()
return smootherSinc.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 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 __init__(self, img, threshold, xysmoothing, zsmoothing, color, alpha):
dataImporter = vtk.vtkImageImport()
simg = np.ascontiguousarray(img, np.uint8)
dataImporter.CopyImportVoidPointer(simg.data, len(simg.data))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
dataImporter.SetWholeExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
self.__smoother = vtk.vtkImageGaussianSmooth()
self.__smoother.SetStandardDeviation(xysmoothing, xysmoothing, zsmoothing)
self.__smoother.SetInputConnection(dataImporter.GetOutputPort())
self.__threshold = vtk.vtkImageThreshold()
self.__threshold.SetInputConnection(self.__smoother.GetOutputPort())
self.__threshold.ThresholdByUpper(threshold)
self.__threshold.ReplaceInOn()
self.__threshold.SetInValue(1)
self.__threshold.ReplaceOutOn()
self.__threshold.SetOutValue(0)
self.__threshold.Update()
contour = vtk.vtkDiscreteMarchingCubes()
contour.SetInputConnection(self.__threshold.GetOutputPort())
contour.ComputeNormalsOn()
contour.SetValue(0, 1)
contour.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(contour.GetOutputPort())
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
triangleCellNormals=vtk.vtkPolyDataNormals()
triangleCellNormals.SetInputConnection(smoother.GetOutputPort())
triangleCellNormals.ComputeCellNormalsOn()
triangleCellNormals.ComputePointNormalsOff()
triangleCellNormals.ConsistencyOn()
triangleCellNormals.AutoOrientNormalsOn()
triangleCellNormals.Update()
triangleCellAn = vtk.vtkMeshQuality()
triangleCellAn.SetInputConnection(triangleCellNormals.GetOutputPort())
triangleCellAn.SetTriangleQualityMeasureToArea()
triangleCellAn.SaveCellQualityOn()
triangleCellAn.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(triangleCellAn.GetOutputPort())
mapper.ScalarVisibilityOn()
mapper.SetScalarRange(.3, 1)
mapper.SetScalarModeToUsePointData()
colorLookupTable = vtk.vtkLookupTable()
colorLookupTable.SetHueRange(.6, 1)
colorLookupTable.Build()
mapper.SetLookupTable(colorLookupTable)
self.SetMapper(mapper)
self.GetProperty().SetColor(*color)
self.GetProperty().SetOpacity(alpha)
def sinWinSmoother(polyData):
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputData(polyData)
smoother.SetNumberOfIterations(15)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(60.0)
smoother.SetPassBand(0.1)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
return smoother.GetOutput()
def sinWinSmoother(polyData):
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputData(polyData);
smoother.SetNumberOfIterations(15);
smoother.BoundarySmoothingOff();
smoother.FeatureEdgeSmoothingOff();
smoother.SetFeatureAngle(60.0);
smoother.SetPassBand(0.1);
smoother.NonManifoldSmoothingOn();
smoother.NormalizeCoordinatesOn();
smoother.Update()
return smoother.GetOutput()
def niftiMask2Surface(img_path, surf_name, smooth_iter=10, filetype="vtk"):
# import the binary nifti image
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(img_path)
reader.Update()
# do marching cubes to create a surface
surface = vtk.vtkDiscreteMarchingCubes()
surface.SetInputConnection(reader.GetOutputPort())
# GenerateValues(number of surfaces, label range start, label range end)
surface.GenerateValues(1, 1, 1)
surface.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(surface.GetOutputPort())
smoother.SetNumberOfIterations(smooth_iter)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInputConnection(smoother.GetOutputPort())
connectivityFilter.SetExtractionModeToLargestRegion()
connectivityFilter.Update()
cleaned = vtk.vtkCleanPolyData()
cleaned.SetInputConnection(connectivityFilter.GetOutputPort())
cleaned.Update()
# doesn't work, but may need in future
# close_holes = vtk.vtkFillHolesFilter()
# close_holes.SetInputConnection(smoother.GetOutputPort())
# close_holes.SetHoleSize(10)
# close_holes.Update()
if filetype == "stl":
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(surf_name)
writer.Write()
if filetype == "ply":
writer = vtk.vtkPLYWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileTypeToASCII()
writer.SetFileName(surf_name)
writer.Write()
if filetype == "vtk":
writer = vtk.vtkPolyDataWriter()
#writer = vtk.vtkDataSetWriter()
writer.SetInputConnection(cleaned.GetOutputPort())
writer.SetFileName(surf_name)
writer.Write()
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 main():
n = 20
radius = 8
blob = make_blob(n, radius)
discrete = vtk.vtkDiscreteMarchingCubes()
discrete.SetInputData(blob)
discrete.GenerateValues(n, 1, n)
smoothing_iterations = 15
pass_band = 0.001
feature_angle = 120.0
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(discrete.GetOutputPort())
smoother.SetNumberOfIterations(smoothing_iterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(feature_angle)
smoother.SetPassBand(pass_band)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
lut = make_colors(n)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smoother.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetScalarRange(0, lut.GetNumberOfColors())
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)
ren_win.SetWindowName('SmoothDiscreteMarchingCubes')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
colors = vtk.vtkNamedColors()
ren.SetBackground(colors.GetColor3d('Burlywood'))
ren_win.Render()
iren.Start()
def show_render(self):
self.reader = vtk.vtkXMLImageDataReader()
if os.sep == '\\':
self.reader.SetFileName('.\\__vtk_files__\\Polydata.vti')
else:
self.reader.SetFileName('__vtk_files__/Polydata.vti')
self.reader.Update()
self.surface = vtk.vtkMarchingCubes()
self.surface.SetInputData(self.reader.GetOutput())
self.surface.ComputeNormalsOn()
self.surface.SetValue(0, 1)
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
smoothing_iterations = 15
pass_band = 0.001
feature_angle = 120.0
self.smoother = vtk.vtkWindowedSincPolyDataFilter()
self.smoother.SetInputConnection(self.surface.GetOutputPort())
self.smoother.SetNumberOfIterations(smoothing_iterations)
self.smoother.BoundarySmoothingOff()
self.smoother.FeatureEdgeSmoothingOff()
self.smoother.SetFeatureAngle(feature_angle)
self.smoother.SetPassBand(pass_band)
self.smoother.NonManifoldSmoothingOn()
self.smoother.NormalizeCoordinatesOn()
self.smoother.Update()
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.smoother.GetOutputPort())
self.mapper.ScalarVisibilityOff()
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self.actor.GetProperty().SetColor(0.105, 0.980, 0)
self.actor.GetProperty().SetAmbient(0.3)
self.actor.GetProperty().SetDiffuse(0.5)
#actor.GetProperty().SetSpecular(0.1);
style = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(style)
self.renderer.AddActor(self.actor)
self.renderer.ResetCamera()
self.iren.Initialize()
self.iren.Start()
def smoothtaubin(polydata, iterations=15, angle=120, passband=0.001):
"""Execute volume reserving smoothing."""
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInput(polydata)
smoother.SetNumberOfIterations(iterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(angle)
smoother.SetPassBand(passband)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
return smoother.GetOutput()
def wrapOpImp(self):
smooth = vtk.vtkWindowedSincPolyDataFilter();
smooth.SetInputData(self.data);
smooth.NormalizeCoordinatesOn();
smooth.NonManifoldSmoothingOn();
smooth.BoundarySmoothingOn();
if self.feature_detect:
smooth.FeatureEdgeSmoothingOn();
else:
smooth.FeatureEdgeSmoothingOff();
smooth.Update();
result = smooth.GetOutput();
return result;
def desenha_surface(self,
tipo='Schwarz_P',
tam=None,
spacing=None,
hole_size=None,
ufunc=None):
if tam is None:
tam = 6, 6, 6
if spacing is None:
spacing = 1.0, 1.0, 1.0
if hole_size is None:
hole_size = 0.1, 0.3
#print hole_size
M = fun_schwartzP(tipo, tam, spacing, hole_size, ufunc)
f = h5py.File("/tmp/camboja_ufunc.hdf5", "w")
f['data'] = M
f['spacing'] = numpy.array(spacing)
self.M = M
self.spacing = spacing
image = to_vtk(M, spacing)
surf = vtk.vtkMarchingCubes()
surf.SetInputData(image)
#surf.SetValue(0,0.5)
surf.SetValue(0, 0.02)
surf.ComputeNormalsOn()
surf.ComputeGradientsOn()
surf.Update()
subdiv = vtk.vtkWindowedSincPolyDataFilter()
subdiv.SetInputData(surf.GetOutput())
subdiv.SetNumberOfIterations(100)
subdiv.SetFeatureAngle(120)
subdiv.SetBoundarySmoothing(60)
subdiv.BoundarySmoothingOn()
subdiv.SetEdgeAngle(90)
subdiv.Update()
## subdiv= vtk.vtkLoopSubdivisionFilter()
## subdiv.SetInput(surf.GetOutput())
## subdiv.Update()
#self.mapper.SetInput(surf.GetOutput())
self.mapper.SetInputData(subdiv.GetOutput())
self.Interactor.Render()
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 CreateFrogSkinActor(fileName, useMarchingCubes):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(fileName)
reader.Update()
isoValue = 20.5
mcubes = vtk.vtkMarchingCubes()
flyingEdges = vtk.vtkFlyingEdges3D()
smoother = vtk.vtkWindowedSincPolyDataFilter()
if useMarchingCubes:
mcubes.SetInputConnection(reader.GetOutputPort())
mcubes.ComputeScalarsOff()
mcubes.ComputeGradientsOff()
mcubes.ComputeNormalsOff()
mcubes.SetValue(0, isoValue)
smoother.SetInputConnection(mcubes.GetOutputPort())
else:
flyingEdges.SetInputConnection(reader.GetOutputPort())
flyingEdges.ComputeScalarsOff()
flyingEdges.ComputeGradientsOff()
flyingEdges.ComputeNormalsOff()
flyingEdges.SetValue(0, isoValue)
smoother.SetInputConnection(flyingEdges.GetOutputPort())
smoothingIterations = 5
passBand = 0.001
featureAngle = 60.0
smoother.SetNumberOfIterations(smoothingIterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(featureAngle)
smoother.SetPassBand(passBand)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(smoother.GetOutputPort())
normals.SetFeatureAngle(featureAngle)
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(stripper.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def smooth_mesh(mesh: Union[vtk.vtkPolyData, pv.PolyData], n_iter=15, pass_band=0.001, feature_angle=120.0):
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputData(mesh)
smoother.SetNumberOfIterations(n_iter)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(feature_angle)
smoother.SetPassBand(pass_band)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
mesh = smoother.GetOutput()
mesh = pv.wrap(mesh)
return mesh
def smooth(inputModel, outputModel, method='Taubin', iterations=30, laplaceRelaxationFactor=0.5, taubinPassBand=0.1, boundarySmoothing=True):
"""Smoothes surface model using a Laplacian filter or Taubin's non-shrinking algorithm.
"""
if method == "Laplace":
smoothing = vtk.vtkSmoothPolyDataFilter()
smoothing.SetRelaxationFactor(laplaceRelaxationFactor)
else: # "Taubin"
smoothing = vtk.vtkWindowedSincPolyDataFilter()
smoothing.SetPassBand(taubinPassBand)
smoothing.SetBoundarySmoothing(boundarySmoothing)
smoothing.SetNumberOfIterations(iterations)
smoothing.SetInputData(inputModel.GetPolyData())
smoothing.Update()
outputModel.SetAndObservePolyData(smoothing.GetOutput())
def create_lungcontour(self):
"""Create a lungcontour using the Marching Cubes algorithm and smooth the surface
"""
self._view_frame.SetStatusText("Calculating lungcontour...")
contourLung = vtk.vtkMarchingCubes()
contourLung.SetValue(0,1)
contourLung.SetInput(self.mask_data)
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInput(contourLung.GetOutput())
smoother.BoundarySmoothingOn()
smoother.SetNumberOfIterations(40)
smoother.Update()
self.lung_mapper.SetInput(smoother.GetOutput())
self.lung_mapper.Update()
self._view_frame.SetStatusText("Calculated lungcontour")
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 load_maps(mol,rendmod,gfx,atomcol): mol.reader = vtk.vtkStructuredPointsReader() mol.reader.SetFileName(mol.mod.dfn) mol.reader.Update() #by calling Update() we read the file mol.iso = vtk.vtkMarchingContourFilter() mol.iso.UseScalarTreeOn() mol.iso.ComputeNormalsOn() mol.iso.SetInputConnection(mol.reader.GetOutputPort()) mol.iso.SetValue(0,mol.mod.isov*mol.mod.sigavg[0]+mol.mod.sigavg[1]) clean = vtk.vtkCleanPolyData() clean.SetInputConnection(mol.iso.GetOutputPort()) clean.ConvertStripsToPolysOn() smooth = vtk.vtkWindowedSincPolyDataFilter() smooth.SetInputConnection(clean.GetOutputPort()) smooth.BoundarySmoothingOn() smooth.GenerateErrorVectorsOn() smooth.GenerateErrorScalarsOn() smooth.NormalizeCoordinatesOn() smooth.NonManifoldSmoothingOn() smooth.FeatureEdgeSmoothingOn() smooth.SetEdgeAngle(90) smooth.SetFeatureAngle(90) smooth.Update() mol.mapper = vtk.vtkOpenGLPolyDataMapper() mol.mapper.SetInputConnection(smooth.GetOutputPort()) ### <- connection here mol.mapper.ScalarVisibilityOff() mol.mapper.Update() mol.acteur= vtk.vtkOpenGLActor() mol.acteur.SetMapper(mol.mapper) mol.acteur.GetProperty().SetColor(mol.col) if rendmod==5: mol.acteur.GetProperty().SetRepresentationToSurface() elif rendmod==6: mol.acteur.GetProperty().SetRepresentationToWireframe() elif rendmod==7: mol.acteur.GetProperty().SetRepresentationToPoints() else : mol.acteur.GetProperty().SetRepresentationToSurface() mol.acteur.GetProperty().SetInterpolationToGouraud() mol.acteur.GetProperty().SetSpecular(.4) mol.acteur.GetProperty().SetSpecularPower(10) gfx.renderer.AddActor(mol.acteur) gfx.renwin.Render()
def smoothMesh(mesh, nIterations=10):
try:
t = time.clock()
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetNumberOfIterations( nIterations )
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
smooth.SetInputData( mesh )
else:
smooth.SetInput( mesh )
smooth.Update()
print ("Surface smoothed")
m2 = smooth.GetOutput()
print " ", m2.GetNumberOfPolys(), "polygons"
elapsedTime(t)
smooth = None
return m2
except:
print "Surface smoothing 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 process_image(self, image):
dims = image.shape
width = dims[1]
height = dims[2]
depth = dims[0]
vtk_data = numpy_support.numpy_to_vtk(num_array=image.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
imgdat = vtk.vtkImageData()
imgdat.GetPointData().SetScalars(vtk_data)
imgdat.SetDimensions(height, width, depth)
imgdat.SetOrigin(0, 0, 0)
spacing = self.image_processing.spacing
imgdat.SetSpacing(spacing[0], spacing[1], spacing[2])
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInputData(imgdat)
dmc.GenerateValues(1, 1, 1)
dmc.Update()
smoothing_iterations = 15
pass_band = 0.001
feature_angle = 120.0
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(dmc.GetOutputPort())
smoother.SetNumberOfIterations(smoothing_iterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(feature_angle)
smoother.SetPassBand(pass_band)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smoother.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
return actor
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
self._wsPDFilter = vtk.vtkWindowedSincPolyDataFilter()
module_utils.setup_vtk_object_progress(self, self._wsPDFilter,
'Smoothing polydata')
# setup some defaults
self._config.numberOfIterations = 20
self._config.passBand = 0.1
self._config.featureEdgeSmoothing = False
self._config.boundarySmoothing = True
self._config.non_manifold_smoothing = False
config_list = [
('Number of iterations', 'numberOfIterations', 'base:int', 'text',
'Algorithm will stop after this many iterations.'),
('Pass band (0 - 2, default 0.1)', 'passBand', 'base:float',
'text', 'Indication of frequency cut-off, the lower, the more '
'it smoothes.'),
('Feature edge smoothing', 'featureEdgeSmoothing', 'base:bool',
'checkbox', 'Smooth feature edges (large dihedral angle)'),
('Boundary smoothing', 'boundarySmoothing', 'base:bool',
'checkbox', 'Smooth boundary edges (edges with only one face).'),
('Non-manifold smoothing', 'non_manifold_smoothing',
'base:bool', 'checkbox',
'Smooth non-manifold vertices, for example output of '
'discrete marching cubes (multi-material).')]
ScriptedConfigModuleMixin.__init__(
self, config_list,
{'Module (self)' : self,
'vtkWindowedSincPolyDataFilter' : self._wsPDFilter})
self.sync_module_logic_with_config()
def load_map(gfx,mapfile,root,status,scale,rendtype,isov,opct,cropentry,nfv,vardeci,varsmooth,color,caller):
if caller != 'fit':
root.configure(cursor='watch')
status.set('Map loading ... please wait')
if mapfile =='' or mapfile == None or mapfile ==() :
MB.showwarning('Info','Select map file')
status.clear()
root.configure(cursor='arrow')
return
try:
gfx.renderer.RemoveActor(gfx.map[0].acteur)
gfx.renderer.RemoveActor(gfx.map[0].box)
except:
pass
if mapfile == 0:
mapfile = gfx.map[0].fn
if gfx.map == []:
gfx.map = [Map()]
gfx.map[0].id=0
if 'map' in caller :
clean_map(gfx) #supression des fichiers sort.s xudi et iudi
if '.vtk' in mapfile:
chdir(gfx.tmpdir)
v2v_out='info_map'
if caller != 'crop':
gfx.map[0].sigma,gfx.map[0].avg = map_sigma_avg(v2v_out)
if scale != gfx.map[0].scale:
spc = None
o = None
f = open(mapfile,'r')
for l in f:
if l.startswith('SPACING'):
spc = l.split()[1:4]
if l.startswith('ORIGIN'):
o = l.split()[1:4]
if spc != None and o != None:
break
f.close()
gfx.map[0].ratio = scale/gfx.map[0].scale
if spc != None and o != None:
system("sed -i -e /^SPACING/s/.*/'SPACING %f %f %f'/ %s"%(float(spc[0])*gfx.map[0].ratio,float(spc[1])*gfx.map[0].ratio,float(spc[2])*gfx.map[0].ratio,mapfile))
system("sed -i -e /^ORIGIN/s/.*/'ORIGIN %f %f %f'/ %s"%(float(o[0])*gfx.map[0].ratio,float(o[1])*gfx.map[0].ratio,float(o[2])*gfx.map[0].ratio,mapfile))
chdir(gfx.workdir)
if '.ezd' in mapfile:
chdir(gfx.tmpdir)
mapfileout = extract_file_from_path(mapfile)[:-4]+'.vtk'
e2v_out='info_map'
system(gfx.vedabin+'/e2v.exe >> %s <<ENDOF\n%s \n%f \n%s \nENDOF'%(e2v_out,mapfile,scale,mapfileout))
mapfile = gfx.tmpdir + '/' + mapfileout
gfx.map[0].sigma,gfx.map[0].avg = map_sigma_avg(e2v_out)
chdir(gfx.workdir)
gfx.map[0].fn = mapfile
gfx.map[0].id = set_map_id(gfx)
gfx.map[0].color = color
gfx.map[0].oldscale = gfx.map[0].scale
gfx.map[0].scale = scale
if nfv !=None:
nfv.set(extract_file_from_path(gfx.map[0].fn))
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(mapfile)
reader.Update() #by calling Update() we read the file
gfx.map[0].reader=reader
iso = vtk.vtkMarchingContourFilter()
iso.UseScalarTreeOn()
iso.ComputeNormalsOn()
iso.SetInputConnection(reader.GetOutputPort())
iso.SetValue(0,isov*gfx.map[0].sigma+gfx.map[0].avg)
gfx.map[0].iso=iso
gfx.map[0].isov=isov
if varsmooth == '1':
#generate vectors
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(iso.GetOutputPort())
clean.ConvertStripsToPolysOn()
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputConnection(clean.GetOutputPort())
smooth.BoundarySmoothingOn()
smooth.GenerateErrorVectorsOn()
smooth.GenerateErrorScalarsOn()
smooth.NormalizeCoordinatesOn()
smooth.NonManifoldSmoothingOn()
smooth.FeatureEdgeSmoothingOn()
smooth.SetEdgeAngle(90)
smooth.SetFeatureAngle(90)
smooth.Update()
if vardeci=='1':
deci = vtk.vtkDecimatePro()
if varsmooth == '0':
deci.SetInput(iso.GetOutput())
else :
deci.SetInput(smooth.GetOutput())
deci.PreserveTopologyOn()
deci.BoundaryVertexDeletionOn()
deci.SplittingOn()
deci.PreSplitMeshOn()
deci.SetTargetReduction(0.97)
gfx.map[0].isdeci='1'
mapper = vtk.vtkOpenGLPolyDataMapper()
mapper.SetInputConnection(deci.GetOutputPort())
else :
mapper = vtk.vtkOpenGLPolyDataMapper()
if varsmooth == '1':
mapper.SetInputConnection(smooth.GetOutputPort()) ### <- connection here
else :
mapper.SetInputConnection(iso.GetOutputPort())
#mapper.SetInput(newpd) ### <- newpd connect there
gfx.map[0].isdeci='0'
mapper.ScalarVisibilityOff()
mapper.Update()
gfx.map[0].mapper=mapper
actor = vtk.vtkOpenGLActor()
actor.SetMapper(mapper)
gfx.map[0].acteur=actor
#actor.SetScale(scale,scale,scale) gerer differament
actor.GetProperty().SetColor(gfx.map[0].color)
actor.PickableOff()
#definition de la box
outline = vtk.vtkOutlineFilter()
outline.SetInput(reader.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInput(outline.GetOutput())
box=vtk.vtkActor()
box.SetMapper( outlineMapper )
box.GetProperty().SetColor((invcolor(gfx.map[0].color)))
box.PickableOff()
#box.SetScale(scale,scale,scale)
gfx.map[0].box = box
#get boxwidget bounds and set axes lenth
(xmin,xmax,ymin,ymax,zmin,zmax)=box.GetBounds()
x=abs(xmin-xmax)/2.0
y=abs(ymin-ymax)/2.0
z=abs(zmin-zmax)/2.0
gfx.axes.SetTotalLength( x, y , z ) #defini la longeurs des axe
init_cam_slab(gfx,(xmin,xmax,ymin,ymax,zmin,zmax)) #defini le slab correct
gfx.map[0].rendtype=rendtype
if rendtype=='Wireframe':
actor.GetProperty().SetRepresentationToWireframe()
elif rendtype=='Surface':
actor.GetProperty().SetRepresentationToSurface()
elif rendtype=='Points':
actor.GetProperty().SetRepresentationToPoints()
actor.GetProperty().SetPointSize(5)
else :
actor.GetProperty().SetRepresentationToWireframe()
gfx.map[0].opct=opct
actor.GetProperty().SetOpacity(opct)
actor.GetProperty().SetInterpolationToGouraud()
actor.GetProperty().SetSpecular(.4)
actor.GetProperty().SetSpecularPower(10)
if cropentry!=None:
if gfx.crop==None:
gfx.crop=Crop(gfx,iso,cropentry,None) #here entryval = None
rendermap(gfx)
#ajustement pour la symetry helicoidale
if gfx.map[0].scale != gfx.map[0].oldscale:#changement de scale
gfx.itf.propagate_scale(gfx,scale,caller)
if gfx.ps != None:
if gfx.ps.solidtype == 'Helicoidal':
gfx.ps.display_tube(gfx,caller)
elif gfx.ps.solidtype == 'Icosahedral' or gfx.ps.solidtype =='Octahedral' or gfx.ps.solidtype == 'Tetrahedral':
gfx.ps.display_platonic(gfx,gfx.ps.ori)
elif gfx.ps.solidtype =='Cn' or gfx.ps.solidtype == 'Dn':
gfx.ps.display_Xn(gfx)
if caller == 'crop':#crop uniquement helicoidal
if gfx.ps != None:
if gfx.ps.solidtype == 'Helicoidal':
gfx.ps.display_tube(gfx,caller)
if caller != 'fit':
status.clear()
root.configure(cursor='arrow')
def FringeSimulator(self, file_name, file_output):
reader = vtk.vtkPLYReader()
reader.SetFileName(file_name)
reader.Update()
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInput(reader.GetOutput())
smooth.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInput(smooth.GetOutput())
normals.SetComputePointNormals(1)
normals.SetComputeCellNormals(1)
normals.Update()
mapper=vtk.vtkDataSetMapper()
mapper.SetInput(smooth.GetOutput())
mapper.SetScalarVisibility(1)
actor = vtk.vtkActor()
actor.GetProperty().SetInterpolationToFlat()
actor.SetMapper(mapper)
self.renderer.AddActor(actor)
key_properties = vtk.vtkInformation()
key_properties.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) #// dummy val.
key_properties.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) #// dummy val.
actor.SetPropertyKeys(key_properties)
actor.SetVisibility(1)
self.renderer.ResetCamera()
cam = self.renderer.GetActiveCamera()
cam_pos = cam.GetPosition()
cam_f = cam.GetFocalPoint()
vcam_pos = numpy.array([float(cam_pos[0]), float(cam_pos[1]), float(cam_pos[2])])
vcam_f = numpy.array([float(cam_f[0]),float(cam_f[1]),float(cam_f[2])])
v = vcam_f - vcam_pos
d = numpy.linalg.norm(v)
vn = v/d
ap = vtk.vtkAppendPolyData()
dist_fringes = cam_pos - vn * -250
for x in xrange(-220, 220):
cube_source= vtk.vtkCubeSource()
cube_source.SetXLength(0.20)
cube_source.SetYLength(80)
cube_source.SetZLength(0.1)
xfm = vtk.vtkTransform()
xfm.Translate(float(x) * 0.40, 0, 0)
xfmPd = vtk.vtkTransformPolyDataFilter()
xfmPd.SetInput(cube_source.GetOutput())
xfmPd.SetTransform(xfm)
ap.AddInput(xfmPd.GetOutput())
ap.Update()
xfm = vtk.vtkTransform()
xfm.Translate(200, dist_fringes[1], dist_fringes[2])
xfmPd = vtk.vtkTransformPolyDataFilter()
xfmPd.SetInput(ap.GetOutput())
xfmPd.SetTransform(xfm)
cube_mapper=vtk.vtkPolyDataMapper()
cube_mapper.SetInput(xfmPd.GetOutput())
fringes_actor = vtk.vtkActor()
fringes_actor.SetMapper(cube_mapper)
fringes_actor.GetProperty().SetColor(1,0,0)
fringesKeyProperties=vtk.vtkInformation()
fringesKeyProperties.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) #// dummy val.
fringesKeyProperties.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) #// dummy val.
fringes_actor.SetPropertyKeys(fringesKeyProperties)
self.renderer.AddActor(fringes_actor)
self.renderer.LightFollowCameraOff()
self.renderer.AutomaticLightCreationOff()
self.renderer.RemoveAllLights()
self.renderer.UpdateLights()
l = vtk.vtkLight()
l.SetLightTypeToSceneLight()
dist_light = cam_pos - vn * 6
l.SetFocalPoint(vcam_f[0], vcam_f[1], vcam_f[2])
l.SetPosition(220, dist_light[1], dist_light[2])
l.PositionalOn()
self.renderer.AddLight(l)
self.renderer.Render()
wf = vtk.vtkWindowToImageFilter()
wf.SetInput(self.ren_win)
wf.Update()
png = vtk.vtkPNGWriter()
png.SetFileName(file_output + ".png")
png.SetInput(wf.GetOutput())
png.Write()
def contour_smooth(vol, voxsz=(1.0, 1.0, 1.0), affine=None, levels=[50],
colors=[np.array([1.0, 0.0, 0.0])], opacities=[0.5], smoothing=10):
""" Take a volume and draw surface contours for any any number of
thresholds (levels) where every contour has its own color and opacity
Parameters
----------
vol : (N, M, K) ndarray
An array representing the volumetric dataset for which we will draw
some beautiful contours .
voxsz : (3,) array_like
Voxel size.
affine : None
Not used.
levels : array_like
Sequence of thresholds for the contours taken from image values needs
to be same datatype as `vol`.
colors : (N, 3) ndarray
RGB values in [0,1].
opacities : array_like
Opacities of contours.
Returns
-------
vtkAssembly
Examples
--------
>>> import numpy as np
>>> from dipy.viz import fvtk
>>> A=np.zeros((10,10,10))
>>> A[3:-3,3:-3,3:-3]=1
>>> r=fvtk.ren()
>>> fvtk.add(r,fvtk.contour(A,levels=[1]))
>>> #fvtk.show(r)
"""
major_version = vtk.vtkVersion.GetVTKMajorVersion()
im = vtk.vtkImageData()
if major_version <= 5:
im.SetScalarTypeToUnsignedChar()
im.SetDimensions(vol.shape[0], vol.shape[1], vol.shape[2])
# im.SetOrigin(0,0,0)
# im.SetSpacing(voxsz[2],voxsz[0],voxsz[1])
if major_version <= 5:
im.AllocateScalars()
else:
im.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 3)
for i in range(vol.shape[0]):
for j in range(vol.shape[1]):
for k in range(vol.shape[2]):
im.SetScalarComponentFromFloat(i, j, k, 0, vol[i, j, k])
ass = vtk.vtkAssembly()
# ass=[]
for (i, l) in enumerate(levels):
# print levels
skinExtractor = vtk.vtkContourFilter()
if major_version <= 5:
skinExtractor.SetInput(im)
else:
skinExtractor.SetInputData(im)
skinExtractor.SetValue(0, l)
#
# Smoothing
# Taken from: https://lorensen.github.io/VTKExamples/site/Python/MeshLabelImageColor/
#
smoother = vtk.vtkWindowedSincPolyDataFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
smoother.SetInput(skinExtractor.GetOutput())
else:
smoother.SetInputConnection(skinExtractor.GetOutputPort())
smoother.SetNumberOfIterations(smoothing) # 30 # this has little effect on the error!
# smoother.BoundarySmoothingOff()
# smoother.FeatureEdgeSmoothingOff()
# smoother.SetFeatureAngle(120.0)
# smoother.SetPassBand(.001) #this increases the error a lot!
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.GenerateErrorScalarsOn()
# smoother.GenerateErrorVectorsOn()
smoother.Update()
skinNormals = vtk.vtkPolyDataNormals()
skinNormals.SetInputConnection(smoother.GetOutputPort())
skinNormals.SetFeatureAngle(60.0)
# No Smoothing
# skinNormals = vtk.vtkPolyDataNormals()
# skinNormals.SetInputConnection(skinExtractor.GetOutputPort())
# skinNormals.SetFeatureAngle(60.0)
skinMapper = vtk.vtkPolyDataMapper()
skinMapper.SetInputConnection(skinNormals.GetOutputPort())
skinMapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
skin.GetProperty().SetOpacity(opacities[i])
# print colors[i]
skin.GetProperty().SetColor(colors[i][0], colors[i][1], colors[i][2])
# skin.Update()
ass.AddPart(skin)
del skin
del skinMapper
del skinExtractor
return ass
def Execute(self):
if self.GaussFiltering:
gauss = vtk.vtkImageGaussianSmooth()
gauss.SetInput(self.Image)
gauss.SetStandardDeviations(self.StandardDeviations)
gauss.SetRadiusFactors(self.RadiusFactors)
if self.Shape.find('2d') != -1:
gauss.SetDimensionality(2)
elif self.Shape.find('3d') != -1:
gauss.SetDimensionality(3)
else:
gauss.SetDimensionality(3)
gauss.Update()
self.Image = gauss.GetOutput()
scalarRange = [0.0,0.0]
if self.FWHMRegion == 'image':
scalarRange = self.Image.GetScalarRange()
elif self.FWHMRegion == 'midline':
extent = self.Image.GetWholeExtent()
newYExtent = extent[2]+(extent[3]-extent[2])/2
clip = vtk.vtkImageClip()
clip.SetInput(self.Image)
clip.SetOutputWholeExtent(extent[0],extent[1],newYExtent,newYExtent,extent[4],extent[5])
clip.ClipDataOn()
clip.Update()
scalarRange = clip.GetOutput().GetScalarRange()
self.FWHMLevel = (scalarRange[1] - scalarRange[0]) * self.FWHMRatio + scalarRange[0]
if self.FWHMBackground != None:
self.FWHMLevel = (scalarRange[1] - self.FWHMBackground) * self.FWHMRatio + self.FWHMBackground
if self.Method == 'levelsets':
if self.Shape.find('2d') != -1:
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetDimensionality(2)
elif self.Shape.find('3d') != -1:
if self.FeatureImageType == 'gradient':
gradientMagnitude = vtkvmtk.vtkvmtkGradientMagnitudeImageFilter()
elif self.FeatureImageType == 'upwind':
gradientMagnitude = vtkvmtk.vtkvmtkUpwindGradientMagnitudeImageFilter()
gradientMagnitude.SetUpwindFactor(self.UpwindFactor)
else:
self.PrintError('Unsupported feature image type: choices are "gradient", "upwind".')
return
else:
gradientMagnitude = vtk.vtkImageGradientMagnitude()
gradientMagnitude.SetInput(self.Image)
gradientMagnitude.Update()
boundedReciprocal = vtkvmtk.vtkvmtkBoundedReciprocalImageFilter()
boundedReciprocal.SetInput(gradientMagnitude.GetOutput())
boundedReciprocal.Update()
self.FeatureImage = vtk.vtkImageData()
self.FeatureImage.DeepCopy(boundedReciprocal.GetOutput())
levelSetsFilter = None
if self.Shape.find('2d') != -1:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSet2DImageFilter()
elif self.Shape.find('3d') != -1:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSetImageFilter()
else:
levelSetsFilter = vtkvmtk.vtkvmtkGeodesicActiveContourLevelSetImageFilter()
levelSetsFilter.SetInput(self.Image)
levelSetsFilter.SetFeatureImage(boundedReciprocal.GetOutput())
levelSetsFilter.SetDerivativeSigma(0.0)
levelSetsFilter.SetAutoGenerateSpeedAdvection(1)
levelSetsFilter.SetNumberOfIterations(self.LevelSetsIterations)
levelSetsFilter.SetPropagationScaling(0.0)
levelSetsFilter.SetCurvatureScaling(self.CurvatureScaling)
levelSetsFilter.SetAdvectionScaling(1.0)
levelSetsFilter.SetIsoSurfaceValue(self.FWHMLevel)
levelSetsFilter.SetInterpolateSurfaceLocation(1)
levelSetsFilter.SetMaximumRMSError(1E-10)
levelSetsFilter.Update()
self.LevelSets = vtk.vtkImageData()
self.LevelSets.DeepCopy(levelSetsFilter.GetOutput())
contourFilter = vtk.vtkMarchingContourFilter()
contourFilter.SetInput(self.LevelSets)
contourFilter.SetValue(0,0.0)
contourFilter.Update()
self.Contour = contourFilter.GetOutput()
elif self.Method == 'fwhm':
contourFilter = vtk.vtkMarchingContourFilter()
contourFilter.SetInput(self.Image)
contourFilter.SetValue(0,self.FWHMLevel)
contourFilter.Update()
self.Contour = contourFilter.GetOutput()
else:
self.PrintError('Unsupported method: choices are "levelsets", "fwhm".')
return
if self.Smoothing:
smoothingFilter = vtk.vtkWindowedSincPolyDataFilter()
smoothingFilter.SetInput(self.Contour)
smoothingFilter.SetNumberOfIterations(self.SmoothingIterations)
smoothingFilter.SetPassBand(self.SmoothingPassBand)
smoothingFilter.Update()
self.Contour = smoothingFilter.GetOutput()
measurementFilter = None
if self.Shape is 'thickplane2d':
measurementFilter = femri2DPlaneThickness()
elif self.Shape is 'cylinder2d':
measurementFilter = femri2DCylinderThickness()
elif self.Shape is 'hollowcylinder2d':
measurementFilter = femri2DHollowCylinderThickness()
elif self.Shape is 'cylinder3d':
measurementFilter = femri3DCylinderThickness()
else:
self.PrintError('Unsupported shape: choices are "thickplane2d", "cylinder2d", "hollowcylinder2d", "cylinder3d".')
return
measurementFilter.Contour = self.Contour
measurementFilter.Center = self.Center
measurementFilter.TiltingAngle = math.radians(self.TiltingAngle)
measurementFilter.RotationAngle = math.radians(self.RotationAngle)
measurementFilter.Execute()
if self.Shape is 'hollowcylinder2d':
measurementFilter.ComputeAreas()
self.InnerArea = measurementFilter.InnerArea
self.OuterArea = measurementFilter.OuterArea
self.Thickness = measurementFilter.Thickness
self.Thickness3D = measurementFilter.Thickness3D
self.Locations = measurementFilter.Locations
self.Contour = measurementFilter.Contour
self.OutputText('\n')
self.OutputText('Thickness: ' + str(self.Thickness) + '\n')
self.OutputText('Thickness3D: ' + str(self.Thickness3D) + '\n')
self.OutputText('Locations: ' + str(self.Locations) + '\n')
if self.Shape is 'hollowcylinder2d':
self.OutputText('InnerArea: ' + str(self.InnerArea) + '\n')
self.OutputText('OuterArea: ' + str(self.OuterArea) + '\n')
self.OutputText('\n')
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 image_to_vtk_polydata(img,considered_cells=None,mesh_center=None,coef=1.0,mesh_fineness=1.0):
start_time = time()
print "--> Generating vtk mesh from image"
vtk_mesh = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_triangles = vtk.vtkCellArray()
vtk_cells = vtk.vtkLongArray()
nx, ny, nz = img.shape
data_string = img.tostring('F')
reader = vtk.vtkImageImport()
reader.CopyImportVoidPointer(data_string, len(data_string))
if img.dtype == np.uint8:
reader.SetDataScalarTypeToUnsignedChar()
else:
reader.SetDataScalarTypeToUnsignedShort()
reader.SetNumberOfScalarComponents(1)
reader.SetDataExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.SetWholeExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.SetDataSpacing(*img.resolution)
if considered_cells is None:
considered_cells = np.unique(img)[1:]
if mesh_center is None:
mesh_center = np.array(img.resolution)*np.array(img.shape)/2.
marching_cube_start_time = time()
print " --> Marching Cubes"
contour = vtk.vtkDiscreteMarchingCubes()
SetInput(contour,reader.GetOutput())
contour.ComputeNormalsOn()
contour.ComputeGradientsOn()
contour.ComputeScalarsOn()
for i,label in enumerate(considered_cells):
contour.SetValue(i,label)
contour.Update()
marching_cube_end_time = time()
print " <-- Marching Cubes : ",contour.GetOutput().GetPoints().GetNumberOfPoints()," Points,",contour.GetOutput().GetNumberOfCells()," Triangles, ",len(np.unique(img)[1:])," Cells [",marching_cube_end_time - marching_cube_start_time,"s]"
marching_cubes = contour.GetOutput()
marching_cubes_cell_data = marching_cubes.GetCellData().GetArray(0)
triangle_cell_start_time = time()
print " --> Listing triangles"
print " - ",marching_cubes.GetNumberOfCells()," triangles"
marching_cubes_triangles = np.sort([[marching_cubes.GetCell(t).GetPointIds().GetId(i) for i in xrange(3)] for t in xrange(marching_cubes.GetNumberOfCells())])
triangle_cell_end_time = time()
print " <-- Listing triangles [",triangle_cell_end_time - triangle_cell_start_time,"s]"
triangle_cell_start_time = time()
print " --> Listing triangle cells"
triangle_cell = np.array([marching_cubes_cell_data.GetTuple(t)[0] for t in xrange(marching_cubes.GetNumberOfCells())],np.uint16)
triangle_cell_end_time = time()
print " <-- Listing triangle cells [",triangle_cell_end_time - triangle_cell_start_time,"s]"
triangle_cell_start_time = time()
print " --> Updating marching cubes mesh"
vtk_mesh = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_triangles = vtk.vtkCellArray()
vtk_cells = vtk.vtkLongArray()
for label in considered_cells:
# cell_start_time = time()
cell_marching_cubes_triangles = marching_cubes_triangles[np.where(triangle_cell == label)]
marching_cubes_point_ids = np.unique(cell_marching_cubes_triangles)
marching_cubes_points = np.array([marching_cubes.GetPoints().GetPoint(p) for p in marching_cubes_point_ids])
marching_cubes_center = marching_cubes_points.mean(axis=0)
marching_cubes_points = marching_cubes_center + coef*(marching_cubes_points-marching_cubes_center) - mesh_center
cell_points = []
for p in xrange(marching_cubes_points.shape[0]):
pid = vtk_points.InsertNextPoint(marching_cubes_points[p])
cell_points.append(pid)
cell_points = array_dict(cell_points,marching_cubes_point_ids)
for t in xrange(cell_marching_cubes_triangles.shape[0]):
poly = vtk_triangles.InsertNextCell(3)
for i in xrange(3):
pid = cell_marching_cubes_triangles[t][i]
vtk_triangles.InsertCellPoint(cell_points[pid])
vtk_cells.InsertValue(poly,label)
# cell_end_time = time()
# print " --> Cell",label,":",cell_marching_cubes_triangles.shape[0],"triangles [",cell_end_time-cell_start_time,"s]"
vtk_mesh.SetPoints(vtk_points)
vtk_mesh.SetPolys(vtk_triangles)
vtk_mesh.GetCellData().SetScalars(vtk_cells)
triangle_cell_end_time = time()
print " <-- Updating marching cubes mesh [",triangle_cell_end_time - triangle_cell_start_time,"s]"
decimation_start_time = time()
print " --> Decimation"
smoother = vtk.vtkWindowedSincPolyDataFilter()
SetInput(smoother,vtk_mesh)
smoother.SetFeatureAngle(30.0)
smoother.SetPassBand(0.05)
smoother.SetNumberOfIterations(25)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
decimate = vtk.vtkQuadricClustering()
SetInput(decimate,smoother.GetOutput())
decimate.SetNumberOfDivisions(*tuple(mesh_fineness*np.array(np.array(img.shape)*np.array(img.resolution)/2.,np.uint16)))
decimate.SetFeaturePointsAngle(30.0)
decimate.CopyCellDataOn()
decimate.Update()
decimation_end_time = time()
print " <-- Decimation : ",decimate.GetOutput().GetPoints().GetNumberOfPoints()," Points,",decimate.GetOutput().GetNumberOfCells()," Triangles, ",len(considered_cells)," Cells [",decimation_end_time - decimation_start_time,"s]"
end_time = time()
print "<-- Generating vtk mesh from image [",end_time-start_time,"s]"
return decimate.GetOutput()
def image_to_vtk_cell_polydata(img,considered_cells=None,mesh_center=None,coef=1.0,mesh_fineness=1.0,smooth_factor=1.0):
start_time = time()
print "--> Generating vtk mesh from image"
vtk_mesh = vtk.vtkPolyData()
vtk_points = vtk.vtkPoints()
vtk_triangles = vtk.vtkCellArray()
vtk_cells = vtk.vtkLongArray()
nx, ny, nz = img.shape
data_string = img.tostring('F')
reader = vtk.vtkImageImport()
reader.CopyImportVoidPointer(data_string, len(data_string))
if img.dtype == np.uint8:
reader.SetDataScalarTypeToUnsignedChar()
else:
reader.SetDataScalarTypeToUnsignedShort()
reader.SetNumberOfScalarComponents(1)
reader.SetDataExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.SetWholeExtent(0, nx - 1, 0, ny - 1, 0, nz - 1)
reader.SetDataSpacing(*img.resolution)
reader.Update()
if considered_cells is None:
considered_cells = np.unique(img)[1:]
if mesh_center is None:
#mesh_center = np.array(img.resolution)*np.array(img.shape)/2.
mesh_center = np.array([0,0,0])
for label in considered_cells:
cell_start_time = time()
cell_volume = (img==label).sum()*np.array(img.resolution).prod()
# mask_data = vtk.vtkImageThreshold()
# mask_data.SetInputConnection(reader.GetOutputPort())
# mask_data.ThresholdBetween(label, label)
# mask_data.ReplaceInOn()
# mask_data.SetInValue(label)
# mask_data.SetOutValue(0)
contour = vtk.vtkDiscreteMarchingCubes()
# contour.SetInput(mask_data.GetOutput())
SetInput(contour,reader.GetOutput())
contour.ComputeNormalsOn()
contour.ComputeGradientsOn()
contour.SetValue(0,label)
contour.Update()
# print " --> Marching Cubes : ",contour.GetOutput().GetPoints().GetNumberOfPoints()," Points,",contour.GetOutput().GetNumberOfCells()," Triangles, 1 Cell"
# decimate = vtk.vtkDecimatePro()
# decimate.SetInputConnection(contour.GetOutputPort())
# # decimate.SetTargetReduction(0.75)
# decimate.SetTargetReduction(0.66)
# # decimate.SetTargetReduction(0.5)
# # decimate.SetMaximumError(2*np.sqrt(3))
# decimate.Update()
smooth_iterations = int(np.ceil(smooth_factor*8.))
smoother = vtk.vtkWindowedSincPolyDataFilter()
SetInput(smoother,contour.GetOutput())
smoother.BoundarySmoothingOn()
# smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOn()
# smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(120.0)
# smoother.SetPassBand(1)
smoother.SetPassBand(0.01)
smoother.SetNumberOfIterations(smooth_iterations)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
divisions = int(np.ceil(np.power(cell_volume,1/3.)*mesh_fineness))
decimate = vtk.vtkQuadricClustering()
# decimate = vtk.vtkQuadricDecimation()
# decimate = vtk.vtkDecimatePro()
# decimate.SetInput(contour.GetOutput())
SetInput(decimate,smoother.GetOutput())
# decimate.SetTargetReduction(0.95)
# decimate.AutoAdjustNumberOfDivisionsOff()
decimate.SetNumberOfDivisions(divisions,divisions,divisions)
decimate.SetFeaturePointsAngle(120.0)
# decimate.AttributeErrorMetricOn()
# decimate.ScalarsAttributeOn()
# decimate.PreserveTopologyOn()
# decimate.CopyCellDataOn()
# decimate.SetMaximumCost(1.0)
# decimate.SetMaximumCollapsedEdges(10000.0)
decimate.Update()
# print " --> Decimation : ",decimate.GetOutput().GetPoints().GetNumberOfPoints()," Points,",decimate.GetOutput().GetNumberOfCells()," Triangles, 1 Cell"
cell_polydata = decimate.GetOutput()
# cell_polydata = smoother.GetOutput()
polydata_points = np.array([cell_polydata.GetPoints().GetPoint(p) for p in xrange(cell_polydata.GetPoints().GetNumberOfPoints())])
polydata_center = polydata_points.mean(axis=0)
polydata_points = polydata_center + coef*(polydata_points-polydata_center) - mesh_center
cell_points = []
for p in xrange(cell_polydata.GetPoints().GetNumberOfPoints()):
pid = vtk_points.InsertNextPoint(polydata_points[p])
cell_points.append(pid)
cell_points = array_dict(cell_points,np.arange(cell_polydata.GetPoints().GetNumberOfPoints()))
for t in xrange(cell_polydata.GetNumberOfCells()):
poly = vtk_triangles.InsertNextCell(3)
for i in xrange(3):
pid = cell_polydata.GetCell(t).GetPointIds().GetId(i)
vtk_triangles.InsertCellPoint(cell_points[pid])
vtk_cells.InsertValue(poly,label)
cell_end_time = time()
print " --> Cell",label,":",decimate.GetOutput().GetNumberOfCells(),"triangles (",cell_volume," microm3 ) [",cell_end_time-cell_start_time,"s]"
vtk_mesh.SetPoints(vtk_points)
vtk_mesh.SetPolys(vtk_triangles)
vtk_mesh.GetCellData().SetScalars(vtk_cells)
print " <-- Cell Mesh : ",vtk_mesh.GetPoints().GetNumberOfPoints()," Points,",vtk_mesh.GetNumberOfCells()," Triangles, ",len(considered_cells)," Cells"
end_time = time()
print "<-- Generating vtk mesh from image [",end_time-start_time,"s]"
return vtk_mesh
line.SetPoint2(0, 1, 2) line.SetResolution(10) lineSweeper = vtk.vtkRotationalExtrusionFilter() lineSweeper.SetResolution(20) lineSweeper.SetInputConnection(line.GetOutputPort()) lineSweeper.SetAngle(270) bump = vtk.vtkBrownianPoints() bump.SetInputConnection(lineSweeper.GetOutputPort()) warp = vtk.vtkWarpVector() warp.SetInputConnection(bump.GetOutputPort()) warp.SetScaleFactor(.2) smooth = vtk.vtkWindowedSincPolyDataFilter() smooth.SetInputConnection(warp.GetOutputPort()) smooth.SetNumberOfIterations(20) smooth.BoundarySmoothingOn() smooth.SetFeatureAngle(120) smooth.SetEdgeAngle(90) smooth.SetPassBand(0.1) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(smooth.GetOutputPort()) cylMapper = vtk.vtkPolyDataMapper() cylMapper.SetInputConnection(normals.GetOutputPort()) cylActor = vtk.vtkActor() cylActor.SetMapper(cylMapper)
def smoothMultipleSegments(self):
import vtkSegmentationCorePython as vtkSegmentationCore
# Generate merged labelmap of all visible segments
segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
visibleSegmentIds = vtk.vtkStringArray()
segmentationNode.GetDisplayNode().GetVisibleSegmentIDs(visibleSegmentIds)
if visibleSegmentIds.GetNumberOfValues() == 0:
logging.info("Smoothing operation skipped: there are no visible segments")
return
mergedImage = vtkSegmentationCore.vtkOrientedImageData()
if not segmentationNode.GenerateMergedLabelmapForAllSegments(mergedImage,
vtkSegmentationCore.vtkSegmentation.EXTENT_UNION_OF_SEGMENTS_PADDED,
None, visibleSegmentIds):
logging.error('Failed to apply smoothing: cannot get list of visible segments')
return
segmentLabelValues = [] # list of [segmentId, labelValue]
for i in range(visibleSegmentIds.GetNumberOfValues()):
segmentId = visibleSegmentIds.GetValue(i)
segmentLabelValues.append([segmentId, i+1])
# Perform smoothing in voxel space
ici = vtk.vtkImageChangeInformation()
ici.SetInputData(mergedImage)
ici.SetOutputSpacing(1, 1, 1)
ici.SetOutputOrigin(0, 0, 0)
# Convert labelmap to combined polydata
# vtkDiscreteFlyingEdges3D cannot be used here, as in the output of that filter,
# each labeled region is completely disconnected from neighboring regions, and
# for joint smoothing it is essential for the points to move together.
convertToPolyData = vtk.vtkDiscreteMarchingCubes()
convertToPolyData.SetInputConnection(ici.GetOutputPort())
convertToPolyData.SetNumberOfContours(len(segmentLabelValues))
contourIndex = 0
for segmentId, labelValue in segmentLabelValues:
convertToPolyData.SetValue(contourIndex, labelValue)
contourIndex += 1
# Low-pass filtering using Taubin's method
smoothingFactor = self.scriptedEffect.doubleParameter("JointTaubinSmoothingFactor")
smoothingIterations = 100 # according to VTK documentation 10-20 iterations could be enough but we use a higher value to reduce chance of shrinking
passBand = pow(10.0, -4.0*smoothingFactor) # gives a nice range of 1-0.0001 from a user input of 0-1
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(convertToPolyData.GetOutputPort())
smoother.SetNumberOfIterations(smoothingIterations)
smoother.BoundarySmoothingOff()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(90.0)
smoother.SetPassBand(passBand)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
# Extract a label
threshold = vtk.vtkThreshold()
threshold.SetInputConnection(smoother.GetOutputPort())
# Convert to polydata
geometryFilter = vtk.vtkGeometryFilter()
geometryFilter.SetInputConnection(threshold.GetOutputPort())
# Convert polydata to stencil
polyDataToImageStencil = vtk.vtkPolyDataToImageStencil()
polyDataToImageStencil.SetInputConnection(geometryFilter.GetOutputPort())
polyDataToImageStencil.SetOutputSpacing(1,1,1)
polyDataToImageStencil.SetOutputOrigin(0,0,0)
polyDataToImageStencil.SetOutputWholeExtent(mergedImage.GetExtent())
# Convert stencil to image
stencil = vtk.vtkImageStencil()
emptyBinaryLabelMap = vtk.vtkImageData()
emptyBinaryLabelMap.SetExtent(mergedImage.GetExtent())
emptyBinaryLabelMap.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
vtkSegmentationCore.vtkOrientedImageDataResample.FillImage(emptyBinaryLabelMap, 0)
stencil.SetInputData(emptyBinaryLabelMap)
stencil.SetStencilConnection(polyDataToImageStencil.GetOutputPort())
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(1) # General foreground value is 1 (background value because of reverse stencil)
imageToWorldMatrix = vtk.vtkMatrix4x4()
mergedImage.GetImageToWorldMatrix(imageToWorldMatrix)
for segmentId, labelValue in segmentLabelValues:
threshold.ThresholdBetween(labelValue, labelValue)
stencil.Update()
smoothedBinaryLabelMap = vtkSegmentationCore.vtkOrientedImageData()
smoothedBinaryLabelMap.ShallowCopy(stencil.GetOutput())
smoothedBinaryLabelMap.SetImageToWorldMatrix(imageToWorldMatrix)
# Write results to segments directly, bypassing masking
slicer.vtkSlicerSegmentationsModuleLogic.SetBinaryLabelmapToSegment(smoothedBinaryLabelMap,
segmentationNode, segmentId, slicer.vtkSlicerSegmentationsModuleLogic.MODE_REPLACE, smoothedBinaryLabelMap.GetExtent())
