def Centerline_Extraction(path_reader,
path_writer,
coeff_smooth=0.001,
nb_iterations=50):
#READ THE SURFACE
print(" ---> Reading Mesh Closed STL surface")
myReader = vmtkscripts.vmtkSurfaceReader()
myReader.InputFileName = path_reader
myReader.Format = 'stl'
myReader.Execute()
print("---> Computing Centerline")
myCenterline = vmtkscripts.vmtkCenterlines()
myCenterline.Surface = myReader.Surface
myCenterline.AppendEndPoints = 1
myCenterline.Resampling = 1
myCenterline.ResamplingStepLength = 0.2
myCenterline.Execute()
myCenterlineSmoother = vmtkscripts.vmtkCenterlineSmoothing()
myCenterlineSmoother.Centerlines = myCenterline.Centerlines
myCenterlineSmoother.SmoothingFactor = coeff_smooth
myCenterlineSmoother.NumberOfSmoothingIterations = nb_iterations
myCenterlineSmoother.Execute()
#WRITE TO STL FILE
print(" ---> Writing results to VTP file ")
myWriter = vmtkscripts.vmtkSurfaceWriter()
myWriter.Surface = myCenterlineSmoother.Centerlines
myWriter.OutputFileName = path_writer
#myWriter.Format = 'vtp'
myWriter.Execute()
def vmtkcenterlines(surface, endpoints=0, interactive=False,
sourcepoints=[0, 0, 0], targetpoints=[0, 0, 0]):
"""Compute centerlines of a vascular geometry.
Args:
surface: Surface mesh of a vascular geometry.
endpoints (bool): Include endpoints. By construction, centerlines do
not reach the source/targetpoints. endpoints=1 bridges the
start/end of the centerlines to the source/targetpoints.
interactive (bool): Select source/targetpoints interactively. This
pops up a VTK window. Follow instructions in terminal.
sourcepoints: Give barycenters of sourcepoints as in '[0.0, 1.0, 2.0]'.
In case of multiple sourcepoints, append the lists of each three
coordinates as in '[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]'.
targetpoints: Give barycenters of targetpoints following same notation
as with sourcepoints.
Returns:
Centerlines. Each cell of the centerlines polydata is a centerline from
one of the sourcepoints to one of the targetpoints.
"""
centerliner = vmtkscripts.vmtkCenterlines()
centerliner.Surface = surface
centerliner.AppendEndPoints = endpoints
if interactive:
centerliner.SeedSelectorName = 'pickpoint'
else:
centerliner.SeedSelectorName = 'pointlist'
centerliner.SourcePoints = sourcepoints
centerliner.TargetPoints = targetpoints
centerliner.Execute()
return centerliner.Centerlines
def vmtkcenterlinesinteractive(surface, endpoints=0):
computer = vmtkscripts.vmtkCenterlines()
computer.Surface = surface
computer.AppendEndPoints = endpoints
computer.SeedSelectorName = 'pickpoint'
computer.Execute()
return computer.Centerlines
def extract_center_lines(self, params):
""" Extract the centerlines of a surface.
The centerline geometry is returned as a vtkPolyData object.
"""
## Get the centers of the inlet and outlet surfaces.
self.get_inlet_outlet_centers(params)
## Read the surface model used for centerline calculation.
self.logger.info("Read surface model from %s" % params.surface_model)
surface_mesh = read_surface(params.surface_model)
#print(surface_mesh)
self.logger.info("Number of points in params.outlet_centers %d" % len(self.outlet_centers))
## Extract centerlines using vmtk.
self.logger.info("Calculating surface centerlines ...");
centerlines = vmtkscripts.vmtkCenterlines()
centerlines.Surface = surface_mesh
centerlines.SeedSelectorName = "pointlist"
centerlines.AppendEndPoints = 1
centerlines.SourcePoints = self.inlet_center
centerlines.TargetPoints = self.outlet_centers
centerlines.Execute()
self.geometry = centerlines.Centerlines
self.logger.info("The surface centerlines have been calculated.");
# Write outlet face names.
self.write_outlet_face_names(params)
def vmtk_compute_centerlines(end_point,
inlet,
method,
outlet,
pole_ids,
resampling_step,
surface,
voronoi,
flip_normals=False,
cap_displacement=None,
delaunay_tolerance=None,
simplify_voronoi=False):
"""
Wrapper for vmtkCenterlines.
compute centerlines from a branching tubular surface. Seed points can be interactively selected on the surface,
or specified as the barycenters of the open boundaries of the surface.
Args:
end_point (int): Toggle append open profile barycenters to centerlines
surface (vktPolyData): Surface model
voronoi (vtkPolyData): Voronoi diagram based on previous centerlines (Optional)
inlet (ndarray): List of source point coordinates
method (str): Seed point selection method
outlet (ndarray): List of target point coordinates
pole_ids (ndarray): Pole ID list of Voronoi diagram (Optional)
resampling_step (float): Resampling step
flip_normals (float): Flip normals after outward normal computation
cap_displacement (float): Displacement of the center points of caps at open profiles along their normals
delaunay_tolerance (float): Tolerance for evaluating coincident points during Delaunay tessellation
simplify_voronoi (bool): Toggle simplification of Voronoi diagram
Returns:
"""
centerlines = vmtkscripts.vmtkCenterlines()
centerlines.Surface = surface
centerlines.SeedSelectorName = method
centerlines.AppendEndPoints = end_point
centerlines.Resampling = 1
centerlines.ResamplingStepLength = resampling_step
centerlines.SourcePoints = inlet
centerlines.TargetPoints = outlet
if voronoi is not None and pole_ids is not None:
centerlines.VoronoiDiagram = voronoi
centerlines.PoleIds = pole_ids
if flip_normals:
centerlines.FlipNormals = 1
if cap_displacement is not None:
centerlines.CapDisplacement = cap_displacement
if delaunay_tolerance is not None:
centerlines.DelaunayTolerance = delaunay_tolerance
if simplify_voronoi:
centerlines.SimplifyVoronoi = 1
centerlines.Execute()
centerlines_output = centerlines.Centerlines
return centerlines, centerlines_output
def vmtkcenterlinesvoronoi(surface, sourcepoints, targetpoints):
computer = vmtkscripts.vmtkCenterlines()
computer.Surface = surface
computer.AppendEndPoints = 1
computer.SeedSelectorName = 'pointlist'
computer.SourcePoints = sourcepoints
computer.TargetPoints = targetpoints
computer.Execute()
return computer.Centerlines, computer.VoronoiDiagram
def vmtkcenterlines(surface, sourcepoints, targetpoints,endpoints=0):
computer = vmtkscripts.vmtkCenterlines()
computer.Surface = surface
computer.SeedSelectorName = 'pointlist'
computer.SourcePoints = sourcepoints
computer.TargetPoints = targetpoints
computer.AppendEndPoints = endpoints
computer.Execute()
return computer.Centerlines
def vmtkcenterlines(surface, sourcepoints, targetpoints, endpoints=0):
computer = vmtkscripts.vmtkCenterlines()
computer.Surface = surface
computer.SeedSelectorName = 'pointlist'
computer.SourcePoints = sourcepoints
computer.TargetPoints = targetpoints
computer.AppendEndPoints = endpoints
# computer.DelaunayTessellationOutputFileName = 'delaunay.vtp'
# computer.VoronoiDiagramOutputFileName = 'voronoi.vtp'
computer.Execute()
return computer.Centerlines
def compute(infile, outfile):
"""
Calls VMTK routine for centerline extraction.
Parameters
----------
infile : string
Path to input mesh with open inlet/outlets (.stl format).
outfile : string
Path to output centerline (.vtp format).
Returns
-------
None
"""
# read surface
centerlineReader = vmtkscripts.vmtkSurfaceReader()
centerlineReader.InputFileName = infile
centerlineReader.Execute()
# centerline
centerline = vmtkscripts.vmtkCenterlines()
centerline.Surface = centerlineReader.Surface
centerline.SeedSelectorName = 'openprofiles'
centerline.AppendEndPoints = 1
centerline.Execute()
# extract branches
branchExtractor = vmtkscripts.vmtkBranchExtractor()
branchExtractor.Centerlines = centerline.Centerlines
branchExtractor.Execute()
# merge centerlines
centerlineMerge = vmtkscripts.vmtkCenterlineMerge()
centerlineMerge.Centerlines = branchExtractor.Centerlines
centerlineMerge.Execute()
# write surface
centerlineWriter = vmtkscripts.vmtkSurfaceWriter()
centerlineWriter.OutputFileName = outfile
centerlineWriter.Surface = centerlineMerge.Centerlines
centerlineWriter.Execute()
def Add_extension(path_reader,
path_writer,
extension_ratio=10,
target_edge_length=0.7,
nb_iterations=5):
myReader = vmtkscripts.vmtkSurfaceReader()
myReader.InputFileName = path_reader
myReader.Format = 'stl'
myReader.Execute()
myCenterline = vmtkscripts.vmtkCenterlines()
myCenterline.Surface = myReader.Surface
myCenterline.SeedSelectorName = 'openprofiles'
myCenterline.Execute()
myExtension = vmtkscripts.vmtkFlowExtensions()
myExtension.Surface = myReader.Surface
myExtension.Centerlines = myCenterline.Centerlines
myExtension.AdaptiveExtensionLength = 1
myExtension.AdaptiveExtensionRadius = 1
myExtension.ExtensionMode = "boundarynormal"
myExtension.ExtensionRatio = extension_ratio
myExtension.Interactive = 0
myExtension.Execute()
mySmoother = vmtkscripts.vmtkSurfaceSmoothing()
mySmoother.Surface = myExtension.Surface
mySmoother.PassBand = 0.3
mySmoother.NumberOfIterations = 5
mySmoother.Execute()
myRemesh = vmtkscripts.vmtkSurfaceRemeshing()
myRemesh.Surface = mySmoother.Surface
myRemesh.ElementSizeMode = 'edgelength'
myRemesh.TargetEdgeLength = target_edge_length
myRemesh.NumberOfIterations = nb_iterations
myRemesh.Execute()
myWriter = vmtkscripts.vmtkSurfaceWriter()
myWriter.Surface = myRemesh.Surface
myWriter.OutputFileName = path_writer
myWriter.Format = 'stl'
myWriter.Execute()
def vmtkcenterlines(surface,
endpoints=0,
interactive=False,
sourcepoints=[0, 0, 0],
targetpoints=[0, 0, 0]):
"""Compute centerlines of a vascular geometry.
Args:
surface: Surface mesh of a vascular geometry.
endpoints (bool): Include endpoints. By construction, centerlines do
not reach the source/targetpoints. endpoints=1 bridges the
start/end of the centerlines to the source/targetpoints.
interactive (bool): Select source/targetpoints interactively. This
pops up a VTK window. Follow instructions in terminal.
sourcepoints: Give barycenters of sourcepoints as in '[0.0, 1.0, 2.0]'.
In case of multiple sourcepoints, append the lists of each three
coordinates as in '[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]'.
targetpoints: Give barycenters of targetpoints following same notation
as with sourcepoints.
Returns:
Centerlines. Each cell of the centerlines polydata is a centerline from
one of the sourcepoints to one of the targetpoints.
"""
centerliner = vmtkscripts.vmtkCenterlines()
centerliner.Surface = surface
centerliner.AppendEndPoints = endpoints
if interactive:
centerliner.SeedSelectorName = 'pickpoint'
else:
centerliner.SeedSelectorName = 'pointlist'
centerliner.SourcePoints = sourcepoints
centerliner.TargetPoints = targetpoints
centerliner.Execute()
return centerliner.Centerlines
def Execute(self):
# Error handling
if self.Surface == None:
self.PrintError(
'Error: no input surface was supplied, ensure file exists, ensure correct environment'
)
# Allocate a renderer and label own renderer in use to prevent multiple renderers from being used
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
# Render and build view of the input surface
self.SurfaceViewer = vmtkscripts.vmtkSurfaceViewer()
self.SurfaceViewer.vmtkRenderer = self.vmtkRenderer
self.SurfaceViewer.Surface = self.Surface
self.SurfaceViewer.BuildView()
# Test question in render window
#queryStr = 'Is this the question you wanted to see? '
#inputStr = self.YesNoInput(queryStr, self.YesNoValidator)
# Surface smoothing, try defaults first then take user input if not adequate
acceptableResult = 0
response = 0
while acceptableResult == 0:
if response == 0:
self.SurfaceSmoothing = vmtkscripts.vmtkSurfaceSmoothing()
self.SurfaceSmoothing.NumberOfIterations = 100
self.PassBand = 0.001
elif response == 1:
self.SurfaceViewer.Surface = self.Surface
self.SurfaceViewer.BuildView()
self.SurfaceSmoothing = vmtkscripts.vmtkSurfaceSmoothing()
#Take passband from user
queryStr = 'Please enter value for pass band (0.001 - 0.1): '
self.SurfaceSmoothing.PassBand = float(
self.InputText(queryStr, self.PassBandValidator))
#Take number of iterations from user
queryStr = 'Please enter number of iterations (1-999): '
self.SurfaceSmoothing.NumberOfIterations = int(
self.InputText(queryStr, self.IterationValidator))
self.SurfaceSmoothing.Surface = self.Surface
self.SurfaceSmoothing.Execute()
self.SurfaceViewer.Surface = self.SurfaceSmoothing.Surface
self.SurfaceViewer.BuildView()
# Accept or reject result of smoothing surface
queryStr = 'Accept result of smoothing?(y/n): '
if (self.YesNoInput(queryStr, self.YesNoValidator)):
acceptableResult = 1
self.Surface = self.SurfaceSmoothing.Surface
else:
acceptableResult = 0
response = 1
# Surface clipping
# The only issue here is that 2 renderers get built 2/2 the structure of vmtkSurfaceClipper
# Issue to be revisited later
acceptableResult = 0
while acceptableResult == 0:
self.SurfaceClipper = vmtkscripts.vmtkSurfaceClipper()
self.SurfaceClipper.Surface = self.Surface
self.SurfaceClipper.Execute()
self.SurfaceViewer.Surface = self.SurfaceClipper.Surface
self.SurfaceViewer.BuildView()
queryStr = 'Accept result of clipping?(y/n): '
if (self.YesNoInput(queryStr, self.YesNoValidator)):
acceptableResult = 1
self.Surface = self.SurfaceClipper.Surface
else:
acceptableResult = 0
self.SurfaceViewer.Surface = self.SurfaceClipper.Surface
self.SurfaceViewer.BuildView()
# Create centerlines based off the acceptable clipped surface
centerliner = vmtkscripts.vmtkCenterlines()
centerliner.Surface = self.Surface
centerliner.SeedSelectorName = 'openprofiles'
centerliner.Execute()
self.Centerlines = centerliner.Centerlines
# Add flow extensions until user has acceptable result
acceptableResult = 0
response = 0
while (acceptableResult == 0):
self.FlowExtensions = vmtkscripts.vmtkFlowExtensions()
self.FlowExtensions.Surface = self.Surface
self.FlowExtensions.Centerlines = self.Centerlines
self.FlowExtensions.AdaptiveExtensionLength = 1
#self.FlowExtensions.CenterlineNormalEstimationDistanceRatio = 1
self.FlowExtensions.Interactive = 0
# Take user extension ratio if response to acceptable outcome question
# Default extension ratio is 10
if (response == 0):
self.FlowExtensions.ExtensionRatio = 10
elif (response == 1):
#Take extension ratio from user
queryStr = 'Please enter value for pass band; default is 20 (min/max 1-50): '
self.FlowExtensions.ExtensionRatio = float(
self.InputText(queryStr, self.ExtensionRatioValidator))
self.FlowExtensions.Execute()
self.SurfaceViewer.Surface = self.FlowExtensions.Surface
self.SurfaceViewer.BuildView()
queryStr = 'Accept flow extensions?(y/n): '
if (self.YesNoInput(queryStr, self.YesNoValidator)):
acceptableResult = 1
self.Surface = self.FlowExtensions.Surface
else:
acceptableResult = 0
response = 1
# self.SurfaceViewer.BuildView()
# Deallocate renderer
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def extract_center_lines(self):
""" Extract the centerlines of a surface.
The centerline geometry is returned as a vtkPolyData object.
"""
self.logger.info("---------- Extract Centerlines ---------- ")
mesh = self.mesh
surface = mesh.surface
surface_caps = mesh.surface_caps
source_centers = []
source_ids = []
target_centers = []
target_ids = []
## Get source and target face centers.
#
for faceID, face in surface_caps.items():
self.logger.info(" ")
self.logger.info("----- Face ID %d ----- " % int(faceID))
center = face.get_center()
ptID, id_center = face.get_id(center)
if face.source:
self.logger.info("Source")
source_centers.extend(center)
self.graphics.add_sphere(center, [1.0, 0.0, 0.0])
self.graphics.add_sphere(id_center, [1.0, 0.0, 0.0])
source_ids.append(ptID)
else:
self.logger.info("Target")
target_centers.extend(center)
self.graphics.add_sphere(center, [0.0, 1.0, 0.0])
self.graphics.add_sphere(id_center, [0.0, 1.0, 0.0])
target_ids.append(ptID)
self.logger.info("Center ID: %d" % ptID)
self.logger.info("Center: %s" % str(center))
self.logger.info("ID Center: %s" % str(id_center))
#__for faceID in face_ids
## Extract centerlines using vmtk.
#
self.logger.info(" ")
self.logger.info("Calculating surface centerlines ...")
centerlines = vmtkscripts.vmtkCenterlines()
centerlines.Surface = mesh.surface
centerlines.AppendEndPoints = 1
"""
source_ids = [67628]
target_ids = [67626, 67627 ,67628 ,67629 ,67630 ,67631 ,67632 ,67633]
surface.GetPoint(source_ids[0], id_center);
self.graphics.add_sphere(id_center, [1.0,0.0,0.0])
"""
use_id_list = True
if use_id_list:
self.logger.info("Use source and target IDs")
self.logger.info("Source IDs: %s" % str(source_ids))
self.logger.info("Target IDs: %s" % str(target_ids))
centerlines.SeedSelectorName = "idlist"
centerlines.SourceIds = source_ids
centerlines.TargetIds = target_ids
else:
centerlines.SeedSelectorName = "pointlist"
centerlines.SourcePoints = source_centers
centerlines.TargetPoints = target_centers
centerlines.Execute()
self.geometry = centerlines.Centerlines
self.logger.info("The surface centerlines have been calculated.")
self.graphics.add_graphics_geometry(self.geometry, [0.0, 0.0, 1.0])
self.logger.info("Split and group centerlines along branches ...")
branch_extractor = vmtkscripts.vmtkBranchExtractor()
branch_extractor.Centerlines = self.geometry
branch_extractor.Execute()
self.branch_geometry = branch_extractor.Centerlines
#print(self.centerlines_branch_geometry)
self.logger.info("The centerlines branches have been calculated.")
file_name = "branch_geometry.vtp"
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(file_name)
writer.SetInputData(self.branch_geometry)
writer.Update()
writer.Write()
outputName = fname1.split('.') + str(diameter) + 'mm.vtp'
vessel = VesselTruncation()
vessel.SetInputSurface(readSurface.GetOutput())
vessel.SetInputCenterlines(readCenterlines.GetOutput())
vessel.SetDiameter(diameter)
vessel.Update()
vessel.SetOutputinputSurface(outputName)
vessel.Write()
vessel.GetVolume()
else:
readSurface = vtk.vtkSTLReader()
readSurface.SetinputSurface(inputSurface)
readSurface.Update()
# generate centerline
centerlines = vmtkscripts.vmtkCenterlines()
centerlines.Surface = readSurface.GetOutput()
centerlines.RadiusArrayName = 'MaximumInscribedSphereRadius'
centerlines.Execute()
centerlines = GenerateCenterline.ExtractGeometry(centerlines)
centerlineviewer = vmtkscripts.vmtkCenterlineViewer()
centerlineviewer.Centerlines = centerlines.Centerlines
#centerlineviewer.CellDataArrayName='GroupIds'
centerlineviewer.PointDataArrayName = 'MaximumInscribedSphereRadius'
centerlineviewer.Legend = 1
centerlineviewer.Execute()
branchClipper = vmtkscripts.vmtkBranchClipper()
branchClipper.Centerlines = centerlines.Centerlines
branchClipper.Surface = readSurface.GetOutput()
def Execute(self):
print("Compute VC orientation")
self.ctrliner = vmtkscripts.vmtkCenterlines()
self.ctrliner.Surface = self.Surface
self.ctrliner.Execute()
self.Centerlines = self.ctrliner.Centerlines
cc = self.Centerlines
ptCoord = []
for c in xrange(cc.GetNumberOfPoints()):
ptCoord.append(cc.GetPoints().GetPoint(c))
ptCoord = np.array(ptCoord)
datamean = ptCoord.mean(axis=0)
uu, dd, vv = np.linalg.svd(ptCoord - datamean)
# vector of the general direction of the VC
# print(vv[0], datamean, datamean+10*vv[0])
VCvect = vv[0]
if self.ComputeCenterlines:
# print(self.Surface)
self.ctrliner = vmtkscripts.vmtkCenterlines()
self.ctrliner.Surface = self.Surface
# self.ctrliner.SeedSelector = 'openprofiles'
self.ctrliner.Execute()
self.Centerlines = self.ctrliner.Centerlines
# self.Surface = self.Centerlines
else:
self.Centerlines = self.Surface
# if self.Centerlines == None:
# self.PrintError('DUMBASS')
self.vmtkReader = vmtkscripts.vmtkSurfaceReader()
self.vmtkRenderer = vmtkscripts.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.SurfaceViewer = vmtkscripts.vmtkSurfaceViewer()
# self.Surface = self.Centerlines
self.SurfaceViewer.Surface = self.Surface
self.SurfaceViewer.Execute()
self.myattr = vmtkscripts.vmtkCenterlineAttributes()
self.myattr.Centerlines = self.Centerlines
self.myattr.Execute()
self.mybranchextractor = vmtkscripts.vmtkBranchExtractor()
self.mybranchextractor.Centerlines = self.myattr.Centerlines
self.mybranchextractor.RadiusArrayName = self.RadiusArrayName
self.mybranchextractor.Execute()
self.ctrl = self.mybranchextractor.Centerlines
self.mywriter = vmtkscripts.vmtkSurfaceWriter()
self.mywriter.Surface = self.mybranchextractor.Centerlines
self.mywriter.OutputFileName = '/home/florian/liverSim/morpho_analysis/test_surf_open_small_ctrlTESTbranc1.vtp'
self.mywriter.Execute()
self.mybifref = vmtkscripts.vmtkBifurcationReferenceSystems()
self.mybifref.Centerlines = self.ctrl
self.mybifref.RadiusArrayName = self.RadiusArrayName
self.mybifref.BlankingArrayName = self.BlankingArrayName
self.mybifref.GroupIdsArrayName = self.GroupIdsArrayName
self.mybifref.CenterlineIdsArrayName = self.CenterlineIdsArrayName
self.mybifref.TractIdsArrayName = self.TractIdsArrayName
self.mybifref.Execute()
self.myvect = vmtkscripts.vmtkBifurcationVectors()
self.myvect.Centerlines = self.ctrl
self.myvect.ReferenceSystems = self.mybifref.ReferenceSystems
self.myvect.RadiusArrayName = self.RadiusArrayName
self.myvect.BlankingArrayName = self.BlankingArrayName
self.myvect.GroupIdsArrayName = self.GroupIdsArrayName
self.myvect.TractIdsArrayName = self.TractIdsArrayName
self.myvect.CenterlineIdsArrayName = self.CenterlineIdsArrayName
self.myvect.ReferenceSystemsNormalArrayName = self.mybifref.ReferenceSystemsNormalArrayName
self.myvect.ReferenceSystemsUpNormalArrayName = self.mybifref.ReferenceSystemsUpNormalArrayName
self.myvect.Execute()
'''TEMP'''
self.mywriter = vmtkscripts.vmtkSurfaceWriter()
self.mywriter.Surface = self.myvect.BifurcationVectors
self.mywriter.OutputFileName = '/home/florian/liverSim/morpho_analysis/test_surf_open_small_bifvect.vtp'
self.mywriter.Execute()
self.mywriter.Surface = self.ctrl
self.mywriter.OutputFileName = '/home/florian/liverSim/morpho_analysis/test_surf_open_small_ctrl.vtp'
self.mywriter.Execute()
'''/TEMP'''
self.numpytator = vmtksurfacetonumpy.vmtkSurfaceToNumpy()
self.numpytator.Surface = self.myvect.BifurcationVectors
self.numpytator.Execute()
vectData = self.numpytator.ArrayDict.values()
cprint(figlet_format('Results!', font='bubble'))
print('\n InPlaneBifurcationVectors angle:')
print(np.degrees(self.angle_between(vectData[0]["InPlaneBifurcationVectors"][1, :],
vectData[0]["InPlaneBifurcationVectors"][2, :])))
# print('\n OutOfPlaneBifurcationVectors angle:')
# print(np.degrees(self.angle_between(vectData[0]["OutOfPlaneBifurcationVectors"][1, :],
# vectData[0]["OutOfPlaneBifurcationVectors"][2, :])))
print('\n bifurcation angle with the VC:')
print(np.degrees(self.angle_between(vectData[0]["OutOfPlaneBifurcationVectors"][0, :],
VCvect)))
'''
weighted average vector between the vectors pointing from the second
to the first reference point on each centerline
'''
print('\n global direction of the birfurcation:')
print(vectData[0]["BifurcationVectors"][0, :])
'''
the origin of the bifurcation is defined as the barycenter of the four reference points
weighted by the surface of the maximum inscribed sphere defined on the reference points.
The reason of the weighting is that small branches have less impact on the position of
the bifurcation origin
'''
print('\n Origin of the bifurcation:')
print(vectData[1][0])
pass
def extract_center_lines(self):
""" Extract the centerlines of a surface.
The centerline geometry is returned as a vtkPolyData object.
"""
self.logger.info("---------- Extract Centerlines ---------- ")
mesh = self.mesh
surface = mesh.surface
surface_caps = mesh.surface_caps
source_centers = []
source_ids = []
target_centers = []
target_ids = []
## Get source and target face centers.
#
for faceID, face in surface_caps.items():
self.logger.info(" ")
self.logger.info("----- Face ID %d ----- " % int(faceID))
center = face.get_center()
ptID, id_center = face.get_id(center)
if face.source:
self.logger.info("Source")
source_centers.extend(center)
self.graphics.add_sphere(center, [1.0, 0.0, 0.0])
self.graphics.add_sphere(id_center, [1.0, 0.0, 0.0])
source_ids.append(ptID)
else:
self.logger.info("Target")
target_centers.extend(center)
self.graphics.add_sphere(center, [0.0, 1.0, 0.0])
self.graphics.add_sphere(id_center, [0.0, 1.0, 0.0])
target_ids.append(ptID)
self.logger.info("Center ID: %d" % ptID)
self.logger.info("Center: %s" % str(center))
self.logger.info("ID Center: %s" % str(id_center))
#__for faceID in face_ids
## Extract centerlines using vmtk.
#
self.logger.info("Calculating surface centerlines ...")
centerlines = vmtkscripts.vmtkCenterlines()
centerlines.Surface = mesh.surface
centerlines.AppendEndPoints = 1
"""
source_ids = [67628]
target_ids = [67626, 67627 ,67628 ,67629 ,67630 ,67631 ,67632 ,67633]
surface.GetPoint(source_ids[0], id_center);
self.graphics.add_sphere(id_center, [1.0,0.0,0.0])
"""
use_id_list = True
if use_id_list:
self.logger.info("Use source and target IDs")
self.logger.info("Source IDs: %s" % str(source_ids))
self.logger.info("Target IDs: %s" % str(target_ids))
centerlines.SeedSelectorName = "idlist"
centerlines.SourceIds = source_ids
centerlines.TargetIds = target_ids
else:
centerlines.SeedSelectorName = "pointlist"
centerlines.SourcePoints = source_centers
centerlines.TargetPoints = target_centers
surfaceFile = '/home/florian/liverSim/morpho_analysis/test_surf_open_small.vtp'
centerlinesFileName = surfaceFile[:-4] + '_ctrlTEST1.vtp'
# centerlinesFile = '/home/florian/liverSim/images/nkouka_piggy_LL/nkouka_ctrlines.vtp'
if not os.path.isfile(surfaceFile):
print('check your input, exiting code\n you failed on the',
time.asctime(time.localtime(time.time())))
exit()
start_time = time()
args = "vmtksurfacereader -ifile " + surfaceFile
myPype = pypes.PypeRun(args)
mySurface = myPype.GetScriptObject('vmtksurfacereader', '0').Surface
myctrl = vmtkscripts.vmtkCenterlines()
myctrl.Surface = mySurface
myctrl.SeedSelectorName = 'openprofiles'
# myctrl.Centerlines = centerlinesFile
myctrl.Execute()
myattr = vmtkscripts.vmtkCenterlineAttributes()
myattr.Centerlines = myctrl.Centerlines
myattr.Execute()
mybranchextractor = vmtkscripts.vmtkBranchExtractor()
mybranchextractor.Centerlines = myattr.Centerlines
mybranchextractor.RadiusArrayName = 'MaximumInscribedSphereRadius'
mybranchextractor.Execute()
# mywriter = vmtkscripts.vmtkSurfaceWriter()
