def SurfaceDistance(threeDRA_path, CBCT_path, output_path):
reader3DRA = vtk.vtkSTLReader()
reader3DRA.SetFileName(threeDRA_path)
reader3DRA.Update()
threeDRA = reader3DRA.GetOutput()
readerCBCT = vtk.vtkSTLReader()
readerCBCT.SetFileName(CBCT_path)
readerCBCT.Update()
CBCT = readerCBCT.GetOutput()
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SetInputData(0, threeDRA)
distanceFilter.SetInputData(1, CBCT)
distanceFilter.Update()
# extract lcc object
connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
connectivityFilter.SetInputData(distanceFilter.GetOutput())
connectivityFilter.Update()
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(output_path)
writer.SetInputData(connectivityFilter.GetOutput())
writer.Update()
def create_or_get_bone_distanced():
cf_bone = create_contour(BONE_ISO_VALUE)
cf_skin = create_contour(SKIN_ISO_VALUE)
color_mapper = vtk.vtkPolyDataMapper()
if not os.path.exists("bone_distance.vtk"):
distance_pdFilter = vtk.vtkDistancePolyDataFilter()
distance_pdFilter.SetInputConnection(0, cf_bone.GetOutputPort())
distance_pdFilter.SetInputConnection(1, cf_skin.GetOutputPort())
distance_pdFilter.SignedDistanceOff()
distance_pdFilter.Update()
# write in the files
writer = vtk.vtkPolyDataWriter()
writer.SetFileName("bone_distance.vtk")
writer.SetInputData(distance_pdFilter.GetOutput())
writer.Write()
color_mapper.SetInputData(distance_pdFilter.GetOutput())
color_mapper.SetScalarRange(distance_pdFilter.GetOutput().GetPointData().GetScalars().GetRange())
else:
reader = vtk.vtkPolyDataReader()
reader.SetFileName("bone_distance.vtk")
reader.Update()
color_mapper.SetInputConnection(reader.GetOutputPort())
color_mapper.SetScalarRange(reader.GetOutput().GetScalarRange())
bone = vtk.vtkActor()
bone.SetMapper(color_mapper)
return bone
def actors_step_4(mapper_bone, mapper_leg):
"""
Creates the visualization actors for step 4
:param mapper_bone: The Mapper of the bone
:param mapper_leg: The Mapper of the leg
:return: The list with the distance bone actor
"""
print('start step 4')
start = time.perf_counter()
if not os.path.isfile(FILENAME_STEP_4):
distance_filter = vtk.vtkDistancePolyDataFilter()
distance_filter.SetInputData(0, mapper_bone.GetInput())
distance_filter.SetInputData(1, mapper_leg.GetInput())
distance_filter.SignedDistanceOff()
distance_filter.Update()
writer_vtk(FILENAME_STEP_4, distance_filter.GetOutput())
reader = reader_vtk(FILENAME_STEP_4)
end = time.perf_counter()
print(f"End of step 4 in: {end - start:0.4f} seconds")
mapper_distance = vtk.vtkPolyDataMapper()
mapper_distance.SetInputData(reader.GetOutput())
mapper_distance.SetScalarRange(reader.GetOutput().GetPointData().GetScalars().GetRange())
actor_distance = vtk.vtkActor()
actor_distance.SetMapper(mapper_distance)
return [actor_distance]
def distance_color(data1, data2, filename):
"""Either generates or reads a polydata object colored depending on the distance to another object
If the filename provided already exists on the file system, the function tries to read it and returns an actor.
If not, the function generates a distance filter and returns an actor (this takes a long time).
"""
if isfile(filename):
dist_polydata = read_from_file(filename)
else:
dist_filter = vtk.vtkDistancePolyDataFilter()
dist_filter.SignedDistanceOff()
dist_filter.SetInputConnection(0, data1.GetOutputPort())
dist_filter.SetInputConnection(1, data2.GetOutputPort())
dist_filter.Update()
dist_polydata = dist_filter.GetOutput()
write_to_file(dist_polydata, filename)
dist_ranges = dist_polydata.GetPointData().GetScalars().GetRange()
color_mapper = vtk.vtkPolyDataMapper()
color_mapper.SetInputData(dist_polydata)
color_mapper.SetScalarRange(dist_ranges[0], dist_ranges[1])
bone_color = vtk.vtkActor()
bone_color.SetMapper(color_mapper)
return bone_color
def _get_assd(p_surf, g_surf):
dist_fltr = vtk.vtkDistancePolyDataFilter()
dist_fltr.SetInputData(1, p_surf)
dist_fltr.SetInputData(0, g_surf)
dist_fltr.SignedDistanceOff()
dist_fltr.Update()
distance_poly = vtk_to_numpy(
dist_fltr.GetOutput().GetPointData().GetArray(0))
return np.mean(distance_poly), dist_fltr.GetOutput()
def polydata_distance(mflo, mref, do_signed=True):
""" distance from mflo to mref """
pdd = vtk.vtkDistancePolyDataFilter()
pdd.SetSignedDistance(do_signed) #pdd.SignedDistanceOff()
pdd.SetInputData(0, mflo)
pdd.SetInputData(1, mref)
pdd.Update()
return pdd.GetOutput()
def surface_distance(p_surf, g_surf):
dist_fltr = vtk.vtkDistancePolyDataFilter()
dist_fltr.SetInputData(1, p_surf)
dist_fltr.SetInputData(0, g_surf)
dist_fltr.SignedDistanceOff()
dist_fltr.Update()
distance = vtk_to_numpy(
dist_fltr.GetOutput().GetPointData().GetArray('Distance'))
return distance, dist_fltr.GetOutput()
def showColorMap(self):
# Get PolyData from Segment 1
self.segment1.CreateClosedSurfaceRepresentation()
ss1 = self.segment1.GetSegmentation()
str1 = ss1.GetNthSegmentID(0)
pl1 = vtk.vtkPolyData()
pl1 = self.segment1.GetClosedSurfaceRepresentation(str1)
# Get PolyData from Segment 2
self.segment2.CreateClosedSurfaceRepresentation()
ss2 = self.segment2.GetSegmentation()
str2 = ss2.GetNthSegmentID(0)
pl2 = vtk.vtkPolyData()
pl2 = self.segment2.GetClosedSurfaceRepresentation(str2)
# Compute distance
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SetInputData(0, pl1)
distanceFilter.SetInputData(1, pl2)
distanceFilter.SignedDistanceOff()
distanceFilter.Update()
# Center 3D view
#slicer.app.layoutManager().tableWidget(0).setVisible(False)
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
# Output model
model = slicer.vtkMRMLModelNode()
slicer.mrmlScene.AddNode(model)
model.SetName('DistanceModelNode')
model.SetAndObservePolyData(distanceFilter.GetOutput())
self.distanceColorMap_display = slicer.vtkMRMLModelDisplayNode()
slicer.mrmlScene.AddNode(self.distanceColorMap_display)
model.SetAndObserveDisplayNodeID(self.distanceColorMap_display.GetID())
self.distanceColorMap_display.SetActiveScalarName('Distance')
self.distanceColorMap_display.SetAndObserveColorNodeID(
'vtkMRMLColorTableNodeFileDivergingBlueRed.txt')
self.distanceColorMap_display.SetScalarVisibility(True)
self.distanceColorMap_display.SetScalarRangeFlag(
0) # Set scalar range mode to Manual
self.distanceColorMap_display.SetScalarRange(0.0, 10.0)
[rmin, rmax] = self.distanceColorMap_display.GetScalarRange()
print(rmin)
print(rmax)
# Scalar bar
self.updateScalarBarRange(0.0, 10.0)
self.updateScalarBarVisibility(True)
# Deactivate visibility of segments (deberia actualizarse el checkbox del GUI pero no lo consigo)
self.updateSegment1Visibility(False)
self.updateSegment2Visibility(False)
def CreateBoneColor(cb, cs):
data = vtk.vtkDistancePolyDataFilter()
data.SignedDistanceOff()
data.SetInputConnection(0, cb.GetOutputPort())
data.SetInputConnection(1, cs.GetOutputPort())
data.Update()
write = vtk.vtkPolyDataWriter()
write.SetFileName("data_bone.vtk")
write.SetInputConnection(data.GetOutputPort())
write.Write()
return data
def surfacedistance(surface, referencesurface, distancearrayname='distance',
signeddistance=False):
"""Calculate unsigned distance to the reference surface at each point of the
input surface."""
distance = vtk.vtkDistancePolyDataFilter()
distance.SetInput(0, surface)
distance.SetInput(1, referencesurface)
if signeddistance:
distance.SetSignedDistance(signeddistance)
distance.Update()
osurface = distance.GetOutput()
osurface.GetPointData().GetArray('Distance').SetName(distancearrayname)
osurface.GetCellData().RemoveArray('Distance')
return osurface
def surfacedistance(surface,
referencesurface,
distancearrayname='distance',
signeddistance=False):
"""Calculate unsigned distance to the reference surface at each point of the
input surface."""
distance = vtk.vtkDistancePolyDataFilter()
distance.SetInput(0, surface)
distance.SetInput(1, referencesurface)
if signeddistance:
distance.SetSignedDistance(signeddistance)
distance.Update()
osurface = distance.GetOutput()
osurface.GetPointData().GetArray('Distance').SetName(distancearrayname)
osurface.GetCellData().RemoveArray('Distance')
return osurface
def ClosestPoint(self,signed=True,inverse=False):
distancefilter=vtk.vtkDistancePolyDataFilter()
if inverse:
distancefilter.SetInputData(1,self.getPolydata('A'))
distancefilter.SetInputData(0,self.getPolydata('B'))
else:
distancefilter.SetInputData(0,self.getPolydata('A'))
distancefilter.SetInputData(1,self.getPolydata('B'))
distancefilter.SetSignedDistance(signed)
distancefilter.Update()
datavtkfloat=distancefilter.GetOutput().GetPointData().GetScalars()
dist = vtk_to_numpy(datavtkfloat)
return dist.tolist()
def calculateBonesContactData(
vtkBoneA,
vtkBoneB,
):
distanceFilter = vtk.vtkDistancePolyDataFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
distanceFilter.SetInput(0, vtkBoneA)
distanceFilter.SetInput(1, vtkBoneB)
else:
distanceFilter.SetInputData(0, vtkBoneA)
distanceFilter.SetInputData(1, vtkBoneB)
distanceFilter.Update()
vtkBoneADistance = distanceFilter.GetOutput()
vtkBoneBDistance = distanceFilter.GetSecondDistanceOutput()
return vtkBoneADistance, vtkBoneBDistance
def create_renderer_4(bone, skin):
'''
Return the fourth renderer
'''
distanceFilter = None
# writing to the file or open from file
if write_file:
# computing the distance between the bone and the skin
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SetInputConnection(0, bone.GetOutputPort())
distanceFilter.SetInputConnection(1, skin.GetOutputPort())
distanceFilter.Update()
# writing data
writer = vtk.vtkPolyDataWriter()
writer.SetInputConnection(distanceFilter.GetOutputPort())
writer.SetFileName('bone_distances.vtk')
writer.Update()
else:
reader = vtk.vtkPolyDataReader()
reader.SetFileName('bone_distances.vtk')
reader.Update()
distanceFilter = reader
# creating bone actor
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(distanceFilter.GetOutputPort())
mapper.SetScalarRange(
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[0],
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[1])
# inversing colors
table = mapper.GetLookupTable()
table.SetHueRange(2 / 3, 0)
table.Build()
bone_actor = vtk.vtkActor()
bone_actor.SetMapper(mapper)
# creating renderer
ren = create_renderer([bone_actor])
ren.SetBackground(0.824, 0.827, 0.824)
return ren
def create_distance_map(tumor, ablation):
distance_filter = vtk.vtkDistancePolyDataFilter()
distance_filter.SignedDistanceOn()
distance_filter.SetInputConnection(1, tumor.GetOutputPort())
distance_filter.SetInputConnection(0, ablation.GetOutputPort())
distance_filter.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(distance_filter.GetOutputPort())
mapper.SetScalarRange(
distance_filter.GetOutput().GetPointData().GetScalars().GetRange()[0],
distance_filter.GetOutput().GetPointData().GetScalars().GetRange()[1])
print(
'Min distance: ',
distance_filter.GetOutput().GetPointData().GetScalars().GetRange()[0])
print(
'Max distance: ',
distance_filter.GetOutput().GetPointData().GetScalars().GetRange()[1])
mapper.SetScalarRange(-5, 15)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# actor.GetProperty().SetOpacity(0.75)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetLookupTable(mapper.GetLookupTable())
scalar_bar.SetTitle("Distance")
scalar_bar.SetNumberOfLabels(3)
hueLut = vtk.vtkLookupTable()
hueLut.SetTableRange(0, 10)
hueLut.SetHueRange(0, 0.4)
hueLut.SetSaturationRange(1, 1)
hueLut.SetValueRange(1, 1)
hueLut.Build()
mapper.SetLookupTable(hueLut)
scalar_bar.SetLookupTable(hueLut)
return actor, scalar_bar
def compute_surface_to_surface_distance(isocontour1: vtk.vtkPolyData, isocontour2: vtk.vtkPolyData) -> vtk.vtkPolyData:
"""Calculates the surface-to-surface distance between two isocontours.
Args:
isocontour1 (vtk.vtkPolyData): The first isocontour.
isocontour2 (vtk.vtkPolyData): The second isocontour.
Returns:
(vtk.vtkPolyData)
"""
cleaner1 = vtk.vtkCleanPolyData()
cleaner1.SetInputData(isocontour1)
cleaner2 = vtk.vtkCleanPolyData()
cleaner2.SetInputData(isocontour2)
distance_filter = vtk.vtkDistancePolyDataFilter()
distance_filter.SetInputConnection(0, cleaner1.GetOutputPort())
distance_filter.SetInputConnection(1, cleaner2.GetOutputPort())
distance_filter.Update()
return distance_filter.GetOutput()
def join2Polydata(vtkPolydata1,
vtkPolydata2,
threshold1='lower',
threshold2='upper',
outThres=False,
saveIntersect=False):
""" Function finds the intersect of two polydata and returns the append of the 2.
"""
import modelTools as mT
# NOTE: Test this to deal with inaccuracies.
# Copy the structure from the inputs.
vtkpolyStructure1 = vtk.vtkPolyData()
vtkpolyStructure1.CopyStructure(vtkPolydata1)
vtkpolyStructure2 = vtk.vtkPolyData()
vtkpolyStructure2.CopyStructure(vtkPolydata2)
# Make triangular mesh from the polydata.
tri1Filt = vtk.vtkTriangleFilter()
tri1Filt.SetInputData(vtkpolyStructure1)
tri1Filt.Update()
tri2Filt = vtk.vtkTriangleFilter()
tri2Filt.SetInputData(vtkpolyStructure2)
tri2Filt.Update()
# Use the clean polydata filter
if False:
tri1CleanFilt = vtk.vtkCleanPolyData()
tri1CleanFilt.SetInputConnection(tri1Filt.GetOutputPort())
tri1CleanFilt.Update()
tri2CleanFilt = vtk.vtkCleanPolyData()
tri2CleanFilt.SetInputConnection(tri2Filt.GetOutputPort())
tri2CleanFilt.Update()
# Try on local grid
locPoint = np.concatenate(
(np.sum(np.array(tri2Filt.GetOutput().GetBounds())[0:4].reshape(
(2, 2)),
axis=1) / 2, np.array([0])))
tri1Loc = transformToLocalCoords(locPoint, tri1CleanFilt.GetOutput())
tri2Loc = transformToLocalCoords(locPoint, tri2CleanFilt.GetOutput())
else:
# Try on local grid
locPoint = np.concatenate(
(np.sum(np.array(tri2Filt.GetOutput().GetBounds())[0:4].reshape(
(2, 2)),
axis=1) / 2, np.array([0])))
tri1Loc = transformToLocalCoords(locPoint, tri1Filt.GetOutput())
tri2Loc = transformToLocalCoords(locPoint, tri2Filt.GetOutput())
# Setup the intersect.
polyIntersectFilt = vtk.vtkIntersectionPolyDataFilter()
polyIntersectFilt.SplitFirstOutputOn()
polyIntersectFilt.SplitSecondOutputOn()
polyIntersectFilt.SetInputData(0, tri1Loc)
polyIntersectFilt.SetInputData(1, tri2Loc)
polyIntersectFilt.Update()
# Temp: save the outputs
if saveIntersect:
io.writeVTPFile('InterSect0.vtp', polyIntersectFilt.GetOutput(0))
io.writeVTPFile('InterSect1.vtp', polyIntersectFilt.GetOutput(1))
io.writeVTPFile('InterSect2.vtp', polyIntersectFilt.GetOutput(2))
# To do: need to check if they intersect.
# Calculate the distance of the intersect
polyDist = vtk.vtkDistancePolyDataFilter()
polyDist.SetInputConnection(0, polyIntersectFilt.GetOutputPort(1))
polyDist.SetInputConnection(1, polyIntersectFilt.GetOutputPort(2))
if saveIntersect:
polyDist.Update()
io.writeVTPFile('distPoly0.vtp', polyDist.GetOutput(0))
io.writeVTPFile('distPoly1.vtp', polyDist.GetOutput(1))
poly0thr = vtk.vtkThreshold()
poly0thr.AllScalarsOn()
poly0thr.SetInputArrayToProcess(0, 0, 0,
vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,
'Distance')
poly0thr.SetInputConnection(polyDist.GetOutputPort(0))
if threshold1 == 'lower':
poly0thr.ThresholdByLower(0.0)
else:
poly0thr.ThresholdByUpper(0.0)
poly0surf = vtk.vtkDataSetSurfaceFilter()
poly0surf.SetInputConnection(poly0thr.GetOutputPort())
poly1thr = vtk.vtkThreshold()
poly1thr.AllScalarsOn()
poly1thr.SetInputArrayToProcess(0, 0, 0,
vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,
'Distance')
poly1thr.SetInputConnection(polyDist.GetOutputPort(1))
if threshold2 == 'upper':
poly1thr.ThresholdByUpper(0.0)
else:
poly1thr.ThresholdByLower(0.0)
poly1surf = vtk.vtkDataSetSurfaceFilter()
poly1surf.SetInputConnection(poly1thr.GetOutputPort())
# Append the polydata's
polyAppendFilt = vtk.vtkAppendPolyData()
polyAppendFilt.SetInputConnection(poly0surf.GetOutputPort())
polyAppendFilt.AddInputConnection(poly1surf.GetOutputPort())
polyAppendFilt.Update()
# Return the appended polydata
if outThres:
return transformToLocalCoords(
-locPoint, polyAppendFilt.GetOutput()), transformToLocalCoords(
-locPoint, poly0surf.GetOutput()), transformToLocalCoords(
-locPoint, poly1surf.GetOutput())
else:
return transformToLocalCoords(-locPoint, polyAppendFilt.GetOutput())
def AccuracyPlotter(meshA, meshB, rmax=[]):
""" Plot mesh accuracy between A and B """
distfilt = vtk.vtkDistancePolyDataFilter()
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
distfilt.SetInputData(0, meshA)
distfilt.SetInputData(1, meshB)
else:
distfilt.SetInput(0, meshA)
distfilt.SetInput(1, meshB)
distfilt.ComputeSecondDistanceOn()
distfilt.Update()
distvtk = distfilt.GetOutput()
# Make absolute value
dist = VN.vtk_to_numpy(distvtk.GetPointData().GetScalars())
dist = np.abs(dist)
vtkfloat = VN.numpy_to_vtk(np.ascontiguousarray(dist), deep=True)
distvtk.GetPointData().SetScalars(vtkfloat)
# if range has not been specified
if not rmax:
dist = VN.vtk_to_numpy(distvtk.GetPointData().GetScalars())
rmax = dist.max()
# Create lookup table
look = vtk.vtkLookupTable()
look.SetHueRange(0.33, 0)
look.SetTableRange(0, rmax)
look.SetSaturationRange(1, 1)
look.SetValueRange(1, 1)
look.Build()
# Create mapper
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
mapper.SetInputData(distvtk)
else:
mapper.SetInput(distvtk)
mapper.SetScalarRange(0, rmax)
mapper.SetLookupTable(look)
# Create Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetColor(1, 1, 1)
actor.GetProperty().LightingOff()
scalarBar = vtk.vtkScalarBarActor()
scalarBar.SetLookupTable(look)
scalarBar.SetTitle('Accuracy')
scalarBar.SetNumberOfLabels(5)
# Add FEM Actor to renderer window
ren = vtk.vtkRenderer()
ren.SetBackground(0.3, 0.3, 0.3)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
# Add actor
ren.AddActor(actor)
ren.AddActor(scalarBar)
# Render
iren.Initialize()
renWin.Render()
renWin.SetWindowName('FEM to STL Accuracy')
iren.Start()
def colorBones(mcBone, mcSkin):
""" Create the colored distance visualisation of the bone to the skin.
The bone is colored from blue (far) to red (close) based on its
distance to the skin. This function looks for a file named
'distanceFilter.vtk' in the current directory and if it exists, it
reads the necessary data from it (thus saving a processing time).
If the file is not to be found, the script processes the distances and
saves the result in a file with the same name as above.
Args:
mcBone: vtkMarchingCubes used to create the bone
mcSkin: vtkMarchingCubes used to create the skin
Returns:
vtkAssembly
"""
SAVED_DISTANCE_FILEPATH = './distanceFilter.vtk'
# Get the distance between the bone and the skin
# If a saved file already exists, use iter
distanceFilter = vtk.vtkDistancePolyDataFilter()
if (os.path.isfile(SAVED_DISTANCE_FILEPATH)):
# Read from saved file
reader = vtk.vtkPolyDataReader()
reader.SetFileName(SAVED_DISTANCE_FILEPATH)
reader.Update()
input = reader.GetOutput()
distanceFilter = vtk.vtkCleanPolyData()
distanceFilter.SetInputData(input)
else:
# Compute the data
distanceFilter.SetInputData(0, mcBone.GetOutput())
distanceFilter.SetInputData(1, mcSkin.GetOutput())
distanceFilter.Update()
# Save to file
writer = vtk.vtkPolyDataWriter()
writer.SetInputConnection(distanceFilter.GetOutputPort())
writer.SetFileName(SAVED_DISTANCE_FILEPATH)
writer.Update()
# Update
distanceFilter.Update()
mapper = vtk.vtkPolyDataMapper()
# Set the coloring range
lut = mapper.GetLookupTable()
lut.SetHueRange(2 / 3, 0)
lut.Build()
# Apply the color
mapper.SetInputConnection(distanceFilter.GetOutputPort())
mapper.SetScalarRange(
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[0],
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[1])
actorBone = vtk.vtkActor()
actorBone.SetMapper(mapper)
actorBone.GetProperty().SetColor(0.9, 0.9, 0.9)
# Group the actors
assembly = vtk.vtkAssembly()
assembly.AddPart(actorBone)
return assembly
def AccuracyPlotter(meshA, meshB, rmax=[]):
""" Plot mesh accuracy between A and B """
distfilt = vtk.vtkDistancePolyDataFilter()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
distfilt.SetInputData(0, meshA)
distfilt.SetInputData(1, meshB)
else:
distfilt.SetInput(0, meshA)
distfilt.SetInput(1, meshB)
distfilt.ComputeSecondDistanceOn()
distfilt.Update()
distvtk = distfilt.GetOutput()
# Make absolute value
dist = VN.vtk_to_numpy(distvtk.GetPointData().GetScalars())
dist = np.abs(dist)
vtkfloat = VN.numpy_to_vtk(np.ascontiguousarray(dist), deep=True)
distvtk.GetPointData().SetScalars(vtkfloat)
# if range has not been specified
if not rmax:
dist = VN.vtk_to_numpy(distvtk.GetPointData().GetScalars())
rmax = dist.max()
# Create lookup table
look = vtk.vtkLookupTable()
look.SetHueRange(0.33, 0)
look.SetTableRange (0, rmax)
look.SetSaturationRange (1, 1)
look.SetValueRange (1, 1)
look.Build()
# Create mapper
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
mapper.SetInputData(distvtk)
else:
mapper.SetInput(distvtk)
mapper.SetScalarRange(0, rmax)
mapper.SetLookupTable(look)
# Create Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetColor(1, 1, 1)
actor.GetProperty().LightingOff()
scalarBar = vtk.vtkScalarBarActor()
scalarBar.SetLookupTable(look)
scalarBar.SetTitle('Accuracy')
scalarBar.SetNumberOfLabels(5)
# Add FEM Actor to renderer window
ren = vtk.vtkRenderer()
ren.SetBackground(0.3, 0.3, 0.3)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
# Add actor
ren.AddActor(actor)
ren.AddActor(scalarBar)
# Render
iren.Initialize()
renWin.Render()
renWin.SetWindowName('FEM to STL Accuracy')
iren.Start()
clipTransparentMapper.ScalarVisibilityOff()
clippedTransparentSkinActor = vtk.vtkActor()
clippedTransparentSkinActor.SetMapper(clipTransparentMapper)
clippedTransparentSkinActor.SetProperty(frontProp)
clippedTransparentSkinActor.SetBackfaceProperty(backProp)
# coloration de l'os selon la distance à la peau
# utilise un fichier sauvegardé si disponible et non forcé à le réécrire
if os.path.isfile(KNEE_COLOR_FILE) and not(WRITE_FILE):
vtkReader = vtk.vtkXMLPolyDataReader()
vtkReader.SetFileName(KNEE_COLOR_FILE)
vtkReader.Update()
boneFilter = vtkReader
else:
boneFilter = vtk.vtkDistancePolyDataFilter()
boneFilter.SetInputConnection(0, boneSurface.GetOutputPort())
boneFilter.SetInputConnection(1, skinSurface.GetOutputPort())
boneFilter.Update()
vtkWriter = vtk.vtkXMLPolyDataWriter()
vtkWriter.SetInputData(boneFilter.GetOutput())
vtkWriter.SetFileName(KNEE_COLOR_FILE)
vtkWriter.Write()
colorsArray = vtk.vtkLookupTable()
colorsArray.SetHueRange(0.8, 0)
colorsArray.Build()
distanceMapper = vtk.vtkPolyDataMapper()
distanceMapper.SetInputConnection(boneFilter.GetOutputPort() )
def CreateRen4(slcr, cam, viewport, background):
if os.path.isfile('data_bone.vtk'):
read = vtk.vtkPolyDataReader()
read.SetFileName("data_bone.vtk")
read.Update()
mapperBone = vtk.vtkPolyDataMapper()
mapperBone.SetInputConnection(read.GetOutputPort())
mapperBone.SetScalarRange(
read.GetOutput().GetPointData().GetScalars().GetRange()[0],
read.GetOutput().GetPointData().GetScalars().GetRange()[1])
else:
contourBone = vtk.vtkContourFilter()
contourBone.SetInputConnection(slcr.GetOutputPort())
contourBone.SetValue(0,75.0)
contourBone.Update()
contourSkin = vtk.vtkContourFilter()
contourSkin.SetInputConnection(slcr.GetOutputPort())
contourSkin.SetValue(0,50.0)
contourSkin.Update()
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SignedDistanceOff()
distanceFilter.SetInputConnection(0, contourBone.GetOutputPort())
distanceFilter.SetInputConnection(1, contourSkin.GetOutputPort())
distanceFilter.Update()
mapperBone = vtk.vtkPolyDataMapper()
mapperBone.SetInputConnection(distanceFilter.GetOutputPort())
mapperBone.SetScalarRange(
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[0],
distanceFilter.GetOutput().GetPointData().GetScalars().GetRange()[1])
outliner = vtk.vtkOutlineFilter()
outliner.SetInputConnection(slcr.GetOutputPort())
outliner.Update()
mapperOutliner = vtk.vtkPolyDataMapper()
mapperOutliner.SetInputConnection(outliner.GetOutputPort())
actorBone = vtk.vtkActor()
actorBone.SetMapper(mapperBone)
actorOutliner = vtk.vtkActor()
actorOutliner.SetMapper(mapperOutliner)
ren = vtk.vtkRenderer()
ren.AddActor(actorBone)
ren.AddActor(actorOutliner)
ren.SetViewport(viewport)
ren.SetActiveCamera(cam)
ren.ResetCamera()
ren.SetBackground(background)
if not os.path.isfile('data_bone.vtk'):
# write a file for restart
write = vtk.vtkPolyDataWriter()
write.SetFileName("data_bone.vtk")
write.SetInputConnection(distanceFilter.GetOutputPort())
write.Write()
return ren
results = {"seed": seed,
"rms": np.zeros(N, np.float32),
"voxel_dims": voxel_dims}
for i in xrange(N):
probe = vtk.vtkProbeFilter()
probe.SetInputData(mech.rsurfs[i])
probe.SetSourceData(mech.cell_fields[i])
probe.Update()
poly = probe.GetOutput()
poly.GetPointData().SetActiveVectors("Displacement")
warp = vtk.vtkWarpVector()
warp.SetInputData(poly)
warp.Update()
dist = vtk.vtkDistancePolyDataFilter()
dist.SetInputData(0, mech.dsurfs[i])
dist.SetInputData(1, warp.GetPolyDataOutput())
dist.Update()
residual = numpy_support.vtk_to_numpy(
dist.GetOutput().GetPointData().GetArray("Distance"))
rms = np.linalg.norm(residual) / np.sqrt(residual.size)
results["rms"][i] = rms
writePoly("DistanceErrors/dist_error{:04d}.vtp".format(i + 1), dist)
fid = open("results.pkl", "wb")
pickle.dump(results, fid, 2)
fid.close()
def cut_example(self,
normal_opt,
centroid_opt,
cut_points,
thres_value=10,
vis_split=False):
# 1. Udregn signed distance fra alle punkter i pred_surface til nearest point on finalCut
plane = vtk.vtkPlaneSource()
plane.SetNormal(-normal_opt)
plane.SetCenter(centroid_opt)
plane.Update()
df = vtk.vtkDistancePolyDataFilter()
df.SetInputData(self.pred_surface)
df.SetInputData(1, plane.GetOutput())
df.Update() # df er afstanden til planet (signed)
#pointTree = vtk.vtkKdTree()
#pointTree.BuildLocatorFromPoints(cut_points)
pd_points = vtk.vtkPolyData()
pd_points.SetPoints(cut_points)
pl = vtk.vtkPointLocator()
pl.SetDataSet(pd_points)
dist = vtk.vtkDoubleArray()
dist.SetNumberOfValues(self.pred_surface.GetNumberOfCells())
for i in range(self.pred_surface.GetNumberOfCells()):
cell_com = self.vtkCenterOfMass(
self.pred_surface.GetCell(i).GetPoints())
#idx = pointTree.FindClosestPoint(1,cell_com)
idx = pl.FindClosestPoint(cell_com)
#print(idx)
if np.sign(
df.GetOutput().GetCellData().GetScalars().GetValue(i)) < 0:
d = 1
else:
d = np.sqrt(vtk.vtkMath().Distance2BetweenPoints(
cell_com, pd_points.GetPoint(idx)))
#d = np.sqrt(vtk.vtkMath().Distance2BetweenPoints(cell_com,COM))
if d > thres_value:
d = 1
else:
d = 0
dist.SetValue(i, d)
# 1b. Assign distance to the vertex
d_surface = vtk.vtkPolyData()
d_surface.DeepCopy(self.pred_surface)
d_surface.GetCellData().SetScalars(dist)
# 2. Remove zero values of the mesh
threshold = vtk.vtkThreshold()
threshold.SetInputData(d_surface)
threshold.ThresholdByUpper(0.5)
threshold.Update()
split_surface = threshold.GetOutput()
geometryFilter = vtk.vtkGeometryFilter()
geometryFilter.SetInputData(split_surface)
geometryFilter.Update()
split_pd = geometryFilter.GetOutput()
# 3. Connectivity filter
# 4. Keep smallest part (el.lign heuristik)
COM = self.vtkCenterOfMass(cut_points)
# Closest to COM
connFilter = vtk.vtkPolyDataConnectivityFilter()
connFilter.SetInputData(split_pd)
connFilter.SetExtractionModeToClosestPointRegion()
connFilter.SetClosestPoint(COM + 5 * normal_opt)
#connFilter.SetExtractionModeToLargestRegion()
connFilter.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
connFilter.Update()
LAA_surface = connFilter.GetOutput()
LAA_surface.GetNumberOfPoints()
# If a small region is found the point is shifted a little in the direction of the normal
if LAA_surface.GetNumberOfPoints() < 100:
condition = True
i = 2
while condition:
#print(i)
i += 1
connFilter.SetClosestPoint(COM + i * normal_opt)
connFilter.Update()
LAA_surface = connFilter.GetOutput()
if LAA_surface.GetNumberOfPoints() > 100:
condition = False
if LAA_surface.GetNumberOfPoints(
) > 0.8 * self.pred_surface.GetNumberOfPoints():
print("Increasing threshold")
LAA_surface = self.cut_example(normal_opt,
centroid_opt,
cut_points,
thres_value=thres_value + 5,
vis_split=vis_split)
else:
if vis_split:
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(split_pd)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(800, 600)
renderWindow.SetPosition(0, 100)
renderWindow.SetWindowName("VTK")
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor) #surface
renderer.SetBackground(1, 1, 1)
renderWindow.AddRenderer(renderer)
renderWindow.Render()
renderWindowInteractor.Start()
return LAA_surface
def run(self, templateMesh, templateLM, templateSLM, meshDirectory,
lmDirectory, slmDirectory, outDirectory, signedDistanceOption):
if (bool(templateSLM) and bool(slmDirectory)):
templateLMTotal = self.mergeLandmarks(templateLM, templateSLM)
else:
templateLMTotal = templateLM
#get template points as vtk array
templatePoints = vtk.vtkPoints()
p = [0, 0, 0]
for i in range(templateLMTotal.GetNumberOfMarkups()):
templateLMTotal.GetMarkupPoint(0, i, p)
templatePoints.InsertNextPoint(p)
# write selected triangles to table
tableNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLTableNode',
'Mean Mesh Distances')
col1 = tableNode.AddColumn()
col1.SetName('Subject ID')
col2 = tableNode.AddColumn()
col2.SetName('Mesh RMSE')
tableNode.SetColumnType('Subject ID', vtk.VTK_STRING)
tableNode.SetColumnType('Mean Mesh Distance', vtk.VTK_STRING)
subjectCount = 0
for meshFileName in os.listdir(meshDirectory):
if (not meshFileName.startswith(".")):
#get corresponding landmarks
lmFilePath, subjectID = self.findCorrespondingFilePath(
lmDirectory, meshFileName)
if (lmFilePath):
currentLMNode = slicer.util.loadMarkupsFiducialList(
lmFilePath)
if bool(slmDirectory): # add semi-landmarks if present
slmFilePath, sID = self.findCorrespondingFilePath(
slmDirectory, meshFileName)
if (slmFilePath):
currentSLMNode = slicer.util.loadMarkupsFiducialList(
slmFilePath)
currentLMTotal = self.mergeLandmarks(
templateLM, currentSLMNode)
else:
print("problem with reading semi-landmarks")
return False
else:
currentLMTotal = currentLMNode
else:
print("problem with reading landmarks")
return False
# if mesh and lm file with same subject id exist, load into scene
meshFilePath = os.path.join(meshDirectory, meshFileName)
currentMeshNode = slicer.util.loadModel(meshFilePath)
#get subject points into vtk array
subjectPoints = vtk.vtkPoints()
p = [0, 0, 0]
for i in range(currentLMTotal.GetNumberOfMarkups()):
currentLMTotal.GetMarkupPoint(0, i, p)
subjectPoints.InsertNextPoint(p)
transform = vtk.vtkThinPlateSplineTransform()
transform.SetSourceLandmarks(subjectPoints)
transform.SetTargetLandmarks(templatePoints)
transform.SetBasisToR() # for 3D transform
transformNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLTransformNode", "TPS")
transformNode.SetAndObserveTransformToParent(transform)
currentMeshNode.SetAndObserveTransformNodeID(
transformNode.GetID())
slicer.vtkSlicerTransformLogic().hardenTransform(
currentMeshNode)
distanceFilter = vtk.vtkDistancePolyDataFilter()
distanceFilter.SetInputData(0, templateMesh.GetPolyData())
distanceFilter.SetInputData(1, currentMeshNode.GetPolyData())
distanceFilter.SetSignedDistance(signedDistanceOption)
distanceFilter.Update()
distanceMap = distanceFilter.GetOutput()
distanceArray = distanceMap.GetPointData().GetArray('Distance')
#meanDistance = np.average(distanceArray)
meanDistance = self.rmse(distanceArray)
#save output distance map
outputNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLModelNode", "ouputDistanceMap")
outputNode.SetAndObservePolyData(distanceMap)
outputFilename = os.path.join(outDirectory,
str(subjectID) + '.vtp')
slicer.util.saveNode(outputNode, outputFilename)
#update table and subjectCount
tableNode.AddEmptyRow()
tableNode.SetCellText(subjectCount, 0, str(subjectID))
tableNode.SetCellText(subjectCount, 1, str(meanDistance))
subjectCount += 1
# clean up
slicer.mrmlScene.RemoveNode(outputNode)
slicer.mrmlScene.RemoveNode(transformNode)
slicer.mrmlScene.RemoveNode(currentMeshNode)
slicer.mrmlScene.RemoveNode(currentLMNode)
def join2Polydata(vtkPolydata1,vtkPolydata2,threshold1='lower',threshold2='upper',outThres=False,saveIntersect=False):
""" Function finds the intersect of two polydata and returns the append of the 2.
"""
# NOTE: Test this to deal with inaccuracies.
# Copy the structure from the inputs.
vtkpolyStructure1 = vtk.vtkPolyData()
vtkpolyStructure1.CopyStructure(vtkPolydata1)
vtkpolyStructure2 = vtk.vtkPolyData()
vtkpolyStructure2.CopyStructure(vtkPolydata2)
# Make triangular mesh from the polydata.
tri1Filt = vtk.vtkTriangleFilter()
tri1Filt.SetInputData(vtkpolyStructure1)
tri1Filt.Update()
tri2Filt = vtk.vtkTriangleFilter()
tri2Filt.SetInputData(vtkpolyStructure2)
tri2Filt.Update()
# Use the clean polydata filter
if False:
tri1CleanFilt = vtk.vtkCleanPolyData()
tri1CleanFilt.SetInputConnection(tri1Filt.GetOutputPort())
tri1CleanFilt.Update()
tri2CleanFilt = vtk.vtkCleanPolyData()
tri2CleanFilt.SetInputConnection(tri2Filt.GetOutputPort())
tri2CleanFilt.Update()
# Try on local grid
locPoint = np.concatenate((np.sum(np.array(tri2Filt.GetOutput().GetBounds())[0:4].reshape((2,2)),axis=1)/2,np.array([0])))
tri1Loc = transformToLocalCoords(locPoint,tri1CleanFilt.GetOutput())
tri2Loc = transformToLocalCoords(locPoint,tri2CleanFilt.GetOutput())
else:
# Try on local grid
locPoint = np.concatenate((np.sum(np.array(tri2Filt.GetOutput().GetBounds())[0:4].reshape((2,2)),axis=1)/2,np.array([0])))
tri1Loc = transformToLocalCoords(locPoint,tri1Filt.GetOutput())
tri2Loc = transformToLocalCoords(locPoint,tri2Filt.GetOutput())
# Setup the intersect.
polyIntersectFilt = vtk.vtkIntersectionPolyDataFilter()
polyIntersectFilt.SplitFirstOutputOn()
polyIntersectFilt.SplitSecondOutputOn()
polyIntersectFilt.SetInputData(0,tri1Loc)
polyIntersectFilt.SetInputData(1,tri2Loc)
polyIntersectFilt.Update()
# Temp: save the outputs
if saveIntersect:
io.writeVTPFile('InterSect0.vtp',polyIntersectFilt.GetOutput(0))
io.writeVTPFile('InterSect1.vtp',polyIntersectFilt.GetOutput(1))
io.writeVTPFile('InterSect2.vtp',polyIntersectFilt.GetOutput(2))
# To do: need to check if they intersect.
# Calculate the distance of the intersect
polyDist = vtk.vtkDistancePolyDataFilter()
polyDist.SetInputConnection(0,polyIntersectFilt.GetOutputPort(1))
polyDist.SetInputConnection(1,polyIntersectFilt.GetOutputPort(2))
if saveIntersect:
polyDist.Update()
io.writeVTPFile('distPoly0.vtp',polyDist.GetOutput(0))
io.writeVTPFile('distPoly1.vtp',polyDist.GetOutput(1))
poly0thr = vtk.vtkThreshold()
poly0thr.AllScalarsOn()
poly0thr.SetInputArrayToProcess(0,0,0,vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,'Distance')
poly0thr.SetInputConnection(polyDist.GetOutputPort(0))
if threshold1=='lower':
poly0thr.ThresholdByLower(0.0)
else:
poly0thr.ThresholdByUpper(0.0)
poly0surf = vtk.vtkDataSetSurfaceFilter()
poly0surf.SetInputConnection(poly0thr.GetOutputPort())
poly1thr = vtk.vtkThreshold()
poly1thr.AllScalarsOn()
poly1thr.SetInputArrayToProcess(0,0,0,vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,'Distance')
poly1thr.SetInputConnection(polyDist.GetOutputPort(1))
if threshold2=='upper':
poly1thr.ThresholdByUpper(0.0)
else:
poly1thr.ThresholdByLower(0.0)
poly1surf = vtk.vtkDataSetSurfaceFilter()
poly1surf.SetInputConnection(poly1thr.GetOutputPort())
# Append the polydata's
polyAppendFilt = vtk.vtkAppendPolyData()
polyAppendFilt.SetInputConnection(poly0surf.GetOutputPort())
polyAppendFilt.AddInputConnection(poly1surf.GetOutputPort())
polyAppendFilt.Update()
# Return the appended polydata
if outThres:
return transformToLocalCoords(-locPoint,polyAppendFilt.GetOutput()),transformToLocalCoords(-locPoint,poly0surf.GetOutput()),transformToLocalCoords(-locPoint,poly1surf.GetOutput())
else:
return transformToLocalCoords(-locPoint,polyAppendFilt.GetOutput())
