def Read_and_Smooth(path_reader, path_writer, coeff_smooth=0.001, nb_iterations=50): #READ THE SURFACE print(" ---> Reading Marching-Cube surface") myReader = vmtkscripts.vmtkSurfaceReader() myReader.InputFileName = path_reader myReader.Format = 'stl' myReader.Execute() #SMOOTH THE SURFACE print(" ---> Smoothing surface with coeff {} and {} ierations".format( coeff_smooth, nb_iterations)) mySmoother = vmtkscripts.vmtkSurfaceSmoothing() mySmoother.Surface = myReader.Surface mySmoother.PassBand = coeff_smooth mySmoother.NumberOfIterations = nb_iterations mySmoother.Execute() #WRITE TO STL FILE print(" ---> Writing results to STL file ") myWriter = vmtkscripts.vmtkSurfaceWriter() myWriter.Surface = mySmoother.Surface myWriter.OutputFileName = path_writer myWriter.Format = 'stl' myWriter.Execute()
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 warp_surface(args): print("warp the surface ") reader = vmtkscripts.vmtkSurfaceReader() reader.InputFileName = args.surface reader.Execute() Surface = reader.Surface boundaries = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() boundaries.SetInputData(Surface) boundaries.Update() boundaryReferenceSystems = vtkvmtk.vtkvmtkBoundaryReferenceSystems() boundaryReferenceSystems.SetInputData(Surface) boundaryReferenceSystems.SetBoundaryRadiusArrayName('BoundaryRadius') boundaryReferenceSystems.SetBoundaryNormalsArrayName('BoundaryNormals') boundaryReferenceSystems.SetPoint1ArrayName('Point1') boundaryReferenceSystems.SetPoint2ArrayName('Point2') boundaryReferenceSystems.Update() ReferenceSystems = boundaryReferenceSystems.GetOutput() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.file_out writer.Input = warp.GetOutput() writer.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 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 vmtksurfacewriter(polydata, path): """Write a vtkPolyData object (e.g. surface and centerlines) to disk. Args: polydata: vtkPolyData object. path: Path to the polydata file. Returns: n/a Note: Writes several polydata formats: vtp, vtk, stl (use only for triangulated surface meshes), ply, tec (tecplot), dat """ writer = vmtkscripts.vmtkSurfaceWriter() writer.Surface = polydata writer.OutputFileName = path writer.Execute()
def Execute(args): print("flip boundary region for flow extensions") flip_id = [int(i) for i in args.flip_ids.strip(" ").split(",")] print(flip_id) surface_reader = vmtkscripts.vmtkSurfaceReader() surface_reader.InputFileName = args.surface_file surface_reader.Execute() surf = surface_reader.Surface for i in flip_id: id_ = surf.GetCellData().GetArray("BoundaryRegion").GetTuple(i) print(id_) new = [(j + 1) % 2 for j in id_] print(new) surf.GetCellData().GetArray("BoundaryRegion").SetTuple(i, new) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file writer.Input = surf writer.Execute()
def Surface_Remesh(path_reader, path_writer, target_edge_length=0.7, nb_iterations=10): myReader = vmtkscripts.vmtkSurfaceReader() myReader.InputFileName = path_reader myReader.Format = 'stl' myReader.Execute() myRemesh = vmtkscripts.vmtkSurfaceRemeshing() myRemesh.Surface = myReader.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 Execute(args): print("clip centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() print(args.clean_ctr) if (args.clean_ctr): cleaner = vtk.vtkCleanPolyData() cleaner.PointMergingOn() cleaner.ConvertPolysToLinesOff() cleaner.SetInputData(reader_ctr.Surface) cleaner.Update() centerlines = cleaner.GetOutput() else: centerlines = reader_ctr.Surface centerlines.BuildLinks() centerlines.BuildCells() reader_br = vmtkscripts.vmtkSurfaceReader() reader_br.InputFileName = args.boundary_file reader_br.Execute() boundary_reference = reader_br.Surface #print(pt1, pt2) #v = pt2 - pt1 #pt1 - pt2 #v_mag = np.linalg.norm(v) #n = v / v_mag #print("should be 1.0", np.linalg.norm(n), n) #https://en.wikipedia.org/wiki/Vector_projection # get starting point from centroid by projecting centroid onto normal direction #neck_projection = np.dot(neck_centroid-pt1, n)*n #neck_start_pt = pt1 + neck_projection new_ctr = vtk.vtkPolyData() new_ctr.DeepCopy(centerlines) locator = vtk.vtkPointLocator() locator.SetDataSet(new_ctr) locator.BuildLocator() cell_loc = vtk.vtkCellLocator() cell_loc.SetDataSet(new_ctr) cell_loc.BuildLocator() clip_ids = [] new_points = vtk.vtkPoints() new_cell_array = vtk.vtkCellArray() scalar = vtk.vtkIntArray() scalar.SetNumberOfComponents(1) scalar.SetNumberOfTuples(new_ctr.GetNumberOfPoints()) scalar.SetName("clipper") scalar.Fill(0) for i in range(boundary_reference.GetNumberOfPoints()): pt = boundary_reference.GetPoint(i) #B pt_b = np.array(pt) #print(pt) #ctr_ptId = locator.FindClosestPoint(pt) id_list = vtk.vtkIdList() locator.FindClosestNPoints(2, pt, id_list) ctr1 = np.array(new_ctr.GetPoint(id_list.GetId(0))) # A ctr2 = np.array(new_ctr.GetPoint(id_list.GetId(1))) #ctr3 = np.array(new_ctr.GetPoint(ctr_ptId + 1)) n_br = np.array(boundary_reference.GetPointData().GetArray( "BoundaryNormals").GetTuple(i)) n_s_2 = np.dot(pt_b - ctr2, n_br) n_s_1 = np.dot(pt_b - ctr1, n_br) if (n_s_1 < 0.0): proj_start = ctr2 start_id = id_list.GetId(0) elif (n_s_2 < 0.0): proj_start = ctr1 start_id = id_list.GetId(1) else: print("two closest points are on same side") #Get each vector normal to outlet n_ctr = np.array(new_ctr.GetPointData().GetArray( "FrenetTangent").GetTuple(start_id)) if (np.dot(n_br, n_ctr) < 0.0): n_ctr = -1.0 * n_ctr #outlet centroid projected onto centerline based on FrenetTangent proj_vec = np.dot(n_br, pt_b - proj_start) * n_ctr proj_end = proj_vec + proj_start two_closest = vtk.vtkIdList() locator.FindClosestNPoints(2, proj_end, two_closest) vec_closest = np.array(new_ctr.GetPoints().GetPoint( two_closest.GetId(0))) - proj_end point_furthest = proj_end - vec_closest new_ctr.GetPoints().SetPoint(two_closest.GetId(1), tuple(point_furthest)) #new_ctr.GetPoints().SetPoint(two_closest.GetId(0), proj_end_other) #new_ctr.GetPointData().GetArray("FrenetTangent").SetTuple(closest_to, tuple(n_br)) cell_id_list = vtk.vtkIdList() new_ctr.GetPointCells(two_closest.GetId(0), cell_id_list) print("haller") print(cell_id_list.GetNumberOfIds()) ctr_cell = new_ctr.GetCell(cell_id_list.GetId(0)) #print(ctr_cell) print(n_s) if (n_s < -np.finfo(float).eps): start = cell_id_match + 1 stop = ctr_cell.GetNumberOfPoints() step = int(1) else: start = cell_id_match - 1 stop = int(-1) step = int(-1) new_poly_line = vtk.vtkPolyLine() for k in range(start, stop, step): old_pt_id = ctr_cell.GetPointIds().GetId(k) scalar.SetTuple(old_pt_id, [1]) #new_pt_d = new_points.InsertNextPoint(new_ctr.GetPonts().GetPoint(old_pt_id) #new_poly_line.GetPointIds().InsertNextId(old_pt_id) new_ctr.GetPointData().AddArray(scalar) new_ctr.GetPointData().SetActiveScalars("clipper") pass_arrays = vtk.vtkPassArrays() pass_arrays.SetInputData(new_ctr) pass_arrays.UseFieldTypesOn() pass_arrays.AddArray(vtk.vtkDataObject.POINT, "clipper") pass_arrays.GetOutput().GetPointData().SetActiveScalars("clipper") pass_arrays.AddFieldType(vtk.vtkDataObject.POINT) pass_arrays.AddFieldType(vtk.vtkDataObject.CELL) pass_arrays.Update() clip = vtk.vtkClipPolyData() clip.SetValue(0.5) clip.SetInputConnection(pass_arrays.GetOutputPort()) clip.InsideOutOn() #clip.GetOutput().GetPointData().CopyScalarsOff() #clip.GetOutput().GetPointData().CopyVectorsOff() #clip.GetOutput().GetCellData().CopyScalarsOff() #clip.GetOutput().GetCellData().CopyVectorsOff() clip.Update() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file if (args.clean_ctr): cleaner2 = vtk.vtkCleanPolyData() cleaner2.PointMergingOn() cleaner.ConvertPolysToLinesOff() cleaner2.SetInputConnection(clip.GetOutputPort()) cleaner2.Update() writer.Input = cleaner2.GetOutput() else: writer.Input = clip.GetOutput() writer.Execute()
def Execute(args): print("clip centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() print(args.clean_ctr) if (args.clean_ctr): cleaner = vtk.vtkCleanPolyData() cleaner.PointMergingOn() cleaner.ConvertPolysToLinesOff() cleaner.SetInputData(reader_ctr.Surface) cleaner.Update() centerlines = cleaner.GetOutput() else: centerlines = reader_ctr.Surface centerlines.BuildLinks() centerlines.BuildCells() reader_br = vmtkscripts.vmtkSurfaceReader() reader_br.InputFileName = args.boundary_file reader_br.Execute() boundary_reference = reader_br.Surface #print(pt1, pt2) #v = pt2 - pt1 #pt1 - pt2 #v_mag = np.linalg.norm(v) #n = v / v_mag #print("should be 1.0", np.linalg.norm(n), n) #https://en.wikipedia.org/wiki/Vector_projection # get starting point from centroid by projecting centroid onto normal direction #neck_projection = np.dot(neck_centroid-pt1, n)*n #neck_start_pt = pt1 + neck_projection new_ctr = vtk.vtkPolyData() new_ctr.DeepCopy(centerlines) locator = vtk.vtkPointLocator() locator.SetDataSet(new_ctr) locator.BuildLocator() clip_ids = [] for i in range(boundary_reference.GetNumberOfPoints()): pt = boundary_reference.GetPoint(i) #B pt_b = np.array(pt) #print(pt) ctr_ptId = locator.FindClosestPoint(pt) ctr1 = np.array(new_ctr.GetPoint(ctr_ptId)) # A ctr2 = np.array(new_ctr.GetPoint(ctr_ptId - 1)) ctr3 = np.array(new_ctr.GetPoint(ctr_ptId + 1)) vec_b = pt_b - ctr1 #Get each vector normal to outlet n_ctr = np.array(new_ctr.GetPointData().GetArray( "FrenetTangent").GetTuple(ctr_ptId)) n_br = np.array(boundary_reference.GetPointData().GetArray( "BoundaryNormals").GetTuple(i)) n_s = np.dot(n_ctr, n_br) if (n_s < 0.0): n_ctr *= -1.0 #print(n_s) #np.dot(n_br, vec_b), # n_dot_b = np.dot(n_ctr, vec_b) #print(n_dot_b, n_dot_b*n_ctr+ctr1) # outlet centroid projected onto centerline based on FrenetTangent projected_pt = n_dot_b * n_ctr + ctr1 # compare previous and next point vec_nm1 = ctr2 - projected_pt vec_np1 = ctr3 - projected_pt n_dot_nm1 = np.dot(n_ctr, vec_nm1) n_dot_np1 = np.dot(n_ctr, vec_np1) #print(n_dot_nm1, n_dot_np1) # one is always positive and one is always negative assert n_dot_nm1 / n_dot_np1 < 0.0 #index info n_out_idx = 0 if (n_dot_nm1 < 0.0 and n_dot_np1 > 0.0): n_out_idx = 1 #print("nm1 is opposite direction of outlet", mvidx) else: n_out_idx = -1 #print("nm1 is same direction of outlet", mvidx) # is projection vector in opposite direction of normal? if (n_dot_b < 0.0): # move closest point mvidx = ctr_ptId else: #move next outside point mvidx = ctr_ptId + n_out_idx #move point #print(ctr_ptId, mvidx, n_out_idx) new_ctr.GetPoints().SetPoint(mvidx, projected_pt) cell_ids_list = vtk.vtkIdList() new_ctr.GetPointCells(mvidx, cell_ids_list) if (cell_ids_list.GetNumberOfIds() > 1): print("something has gone wrong, this is a bifurcation point") else: cell = new_ctr.GetCell(cell_ids_list.GetId(0)) for i in range(cell.GetNumberOfPoints()): if (cell.GetPointIds().GetId(i) == mvidx): # cell_id, point_id, numberOfPoints clip_ids.append((cell_ids_list.GetId(0), i, cell.GetNumberOfPoints(), n_out_idx)) print(clip_ids) outputLines = vtk.vtkCellArray() output = vtk.vtkPolyData() lengthArray = vtk.vtkDoubleArray() lengthArray.SetName("length") lengthArray.SetNumberOfComponents(1) cell_Ids = vtk.vtkIdList() new_points = vtk.vtkPoints() points_list = [] for i in range(new_ctr.GetNumberOfCells()): cell = new_ctr.GetCell(i) if cell.GetCellType() not in (vtk.VTK_POLY_LINE, vtk.VTK_LINE): continue edge = [] cell_ends = [0, cell.GetNumberOfPoints() - 1] edge.append(cell.GetPointIds().GetId(cell_ends[0])) edge.append(cell.GetPointIds().GetId(cell_ends[1])) start_pt = [] for e, idx in zip(edge, cell_ends): new_ctr.GetPointCells(e, cell_Ids) start_pt.append((cell_Ids.GetNumberOfIds(), idx)) cell_bounds = [t[1] for t in clip_ids if t[0] == i] # get cell point bounds cell_max_idx = [i[1] for i in start_pt if i[0] == 1] start_pt.sort(key=lambda tup: tup[0]) print(start_pt, cell_bounds, cell_max_idx) if (len(cell_bounds) == 2): # starts and ends outside bnd = sorted(cell_bounds) elif (len(cell_bounds) == 0): #starts and ends inside bnd = cell_ends elif (len(cell_bounds) == 1): #one point inside and one outside bnds = sorted([cell_ends[0], cell_bounds[0], cell_ends[1]]) if (start_pt[0][0] == 1 and start_pt[0][1] != 0): #print("start out") bnd = bnds[:-1] elif (start_pt[0][0] == 1 and start_pt[0][1] == 0): bnd = bnds[1:] else: print("whoops") #print(bnd) #if (args.clean_ctr): cell_branch_pt = [] #cell_Ids = vtk.vtkIdList() for j in range(cell.GetNumberOfPoints()): new_ctr.GetPointCells(cell.GetPointIds().GetId(j), cell_Ids) if (cell_Ids.GetNumberOfIds() > 1 and j not in cell_ends): cell_branch_pt.append(j) #print(cell.GetPointIds().GetId(j)) for j in cell_branch_pt: bnd.append(j) bnd.sort() #print("yeay") #print(bnd) for j in range(len(bnd) - 1): start_ = bnd[j] end_ = bnd[j + 1] pts_ids = vtk.vtkIdList() length = 0.0 prevPoint = cell.GetPoints().GetPoint(0) for k in range(start_, end_ + 1): pt_id = cell.GetPointIds().GetId(k) pts_ids.InsertNextId(pt_id) point = cell.GetPoints().GetPoint(k) length += vtk.vtkMath.Distance2BetweenPoints(prevPoint, point)**0.5 if (pt_id not in points_list): points_list.append(pt_id) prevPoint = point lengthArray.InsertNextTuple([length]) new_polyline = addPolyLine(pts_ids) outputLines.InsertNextCell(new_polyline) #if(k == j): #boundary_reference output.SetPoints(new_ctr.GetPoints()) output.SetLines(outputLines) output.GetCellData().AddArray(lengthArray) for i in range(new_ctr.GetPointData().GetNumberOfArrays()): output.GetPointData().AddArray(new_ctr.GetPointData().GetArray(i)) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file if (args.clean_ctr): cleaner2 = vtk.vtkCleanPolyData() cleaner2.PointMergingOn() cleaner.ConvertPolysToLinesOff() cleaner2.SetInputData(output) cleaner2.Update() writer.Input = cleaner2.GetOutput() else: writer.Input = output writer.Execute()
def run_script(args): print("extract dome from clipped cfd surface") reader_dome = vmtkscripts.vmtkSurfaceReader() reader_dome.InputFileName = args.surface_file reader_dome.Execute() dome_surface = reader_dome.Surface wall_reader = vmtkscripts.vmtkSurfaceReader() wall_reader.InputFileName = args.wall_file wall_reader.Execute() #mesh_reader = vmtkscripts.vmtkMeshReader() #mesh_reader.InputFileName = args.mesh_file #mesh_reader.Execute() #mesh2surf = vmtkscripts.vmtkMeshToSurface() #mesh2surf.Mesh = mesh_reader.Mesh #mesh2surf.CleanOutput = 0 #mesh2surf.Execute() #scale_cfd = vmtkscripts.vmtkSurfaceScaling() #scale_cfd.ScaleFactor = 1000 # meters to mm #scale_cfd.Surface = mesh2surf.Surface #scale_cfd.Execute() dist = vmtkscripts.vmtkSurfaceDistance() dist.Surface = wall_reader.Surface dist.ReferenceSurface = dome_surface dist.DistanceArrayName = "distance" dist.DistanceVectorsArrayName = "distance_vectors" dist.SignedDistanceArrayName = "signed_distance" dist.Execute() clip_copy = vtk.vtkPolyData() clip_copy.DeepCopy(dist.Surface) clip = vmtkscripts.vmtkSurfaceClipper() clip.Surface = dist.Surface clip.Interactive = 0 clip.InsideOut = 1 clip.ClipArrayName = "distance" clip.ClipValue = 0.1 clip.Execute() conn = vmtkscripts.vmtkSurfaceConnectivity() conn.Surface = clip.Surface conn.Method = "largest" conn.CleanOutput = 0 conn.Execute() normals = vmtkscripts.vmtkSurfaceNormals() normals.Surface = conn.Surface #accept defaults normals.Execute() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.file_out writer.Input = normals.Surface writer.Execute() if (args.inverse_out): clip_inverse = vmtkscripts.vmtkSurfaceClipper() clip_inverse.Surface = clip_copy clip_inverse.Interactive = 0 clip_inverse.InsideOut = 0 clip_inverse.ClipArrayName = "distance" clip_inverse.ClipValue = 0.1 clip_inverse.Execute() conn2 = vmtkscripts.vmtkSurfaceConnectivity() conn2.Surface = clip_inverse.Surface conn2.Method = "all" conn2.CleanOutput = 0 conn2.Execute() writer2 = vmtkscripts.vmtkSurfaceWriter() writer2.OutputFileName = args.inverse_out writer2.Input = conn2.Surface writer2.Execute()
def Execute(args): print("evaluate centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() print(args.clean_ctr) if (args.clean_ctr): cleaner = vtk.vtkCleanPolyData() cleaner.PointMergingOn() cleaner.SetInputData(reader_ctr.Surface) cleaner.Update() centerlines = cleaner.GetOutput() else: centerlines = reader_ctr.Surface centerlines.BuildLinks() centerlines.BuildCells() reader_br = vmtkscripts.vmtkSurfaceReader() reader_br.InputFileName = args.surface reader_br.Execute() #if (reader_br.Surface.GetPointData().GetNormals() == None): #normalsFilter = vmtkscripts.vmtkSurfaceNormals() #normalsFilter.ComputeCellNormals = 1 #normalsFilter.Surface = reader_br.Surface #normalsFilter.NormalsArrayName = 'Normals' #normalsFilter.Execute() #surface_reference = normalsFilter.Surface #else: surface_reference = reader_br.Surface locator_surf = vtk.vtkPointLocator() locator_surf.SetDataSet(surface_reference) locator_surf.BuildLocator() locator_cell = vtk.vtkCellLocator() locator_cell.SetDataSet(surface_reference) locator_cell.BuildLocator() cell_Ids = vtk.vtkIdList() outputLines = vtk.vtkCellArray() output = vtk.vtkPolyData() triangles = vtk.vtkCellArray() triangle_pd = vtk.vtkPolyData() triangle_pts = vtk.vtkPoints() lengthArray = vtk.vtkDoubleArray() lengthArray.SetName("length") lengthArray.SetNumberOfComponents(1) pts_ids = vtk.vtkIdList() factor = 1.0 factor2 = 2.0 pd_count = 0 size_range = [0.0, 0.0] bifurcation_info = {} for i in range(centerlines.GetNumberOfCells()): bifurcation_info[i] = {"clip_id": [], "cell_id": []} cell = centerlines.GetCell(i) if cell.GetCellType() not in (vtk.VTK_POLY_LINE, vtk.VTK_LINE): continue n_cell_pts = cell.GetNumberOfPoints() start_end_pt = [0, n_cell_pts - 1] for j in start_end_pt: pt_id_pd = cell.GetPointIds().GetId(j) centerlines.GetPointCells(pt_id_pd, cell_Ids) if (cell_Ids.GetNumberOfIds() > 1): radius = centerlines.GetPointData().GetArray( "MaximumInscribedSphereRadius").GetTuple(pt_id_pd)[0] length = 0.0 radius2 = 0.0 prev_point = centerlines.GetPoint(pt_id_pd) if (j == start_end_pt[0]): step = 1 stop = start_end_pt[-1] else: step = -1 stop = -1 for k in range(j, stop, step): point = centerlines.GetPoint(cell.GetPointIds().GetId(k)) length += vtk.vtkMath.Distance2BetweenPoints( prev_point, point)**0.5 prev_point = point if (length > (factor * radius + factor2 * radius2)): #print(length) pl_vec = centerlines.GetPointData().GetArray( "FrenetTangent").GetTuple( cell.GetPointIds().GetId(k)) pl = vtk.vtkPlane() pl.SetOrigin(point) pl.SetNormal(pl_vec) cut = vtk.vtkCutter() cut.SetInputData(surface_reference) cut.SetCutFunction(pl) cut.Update() ex = vtk.vtkPolyDataConnectivityFilter() ex.SetInputConnection(cut.GetOutputPort()) #ex.SetExtractionModeToAllRegions() ex.SetExtractionModeToClosestPointRegion() ex.SetClosestPoint(point) ex.Update() lp = ex.GetOutput() close_cell(lp) cutStrips = vtk.vtkStripper( ) # Forms loops (closed polylines) from cutter cutStrips.SetInputData(lp) cutStrips.Update() cutPoly = vtk.vtkPolyData( ) # This trick defines polygons as polyline loop cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints()) cutPoly.SetPolys((cutStrips.GetOutput()).GetLines()) area_test = ComputePolygonArea(cutPoly) size_ratio = area_test / (np.pi * radius**2) #print(area_test, radius, size_ratio) if (size_ratio > 2.0): continue cv, offset, shape = ComputeBranchSectionShape( cutPoly, point) if (cv > 0.2): continue if (offset > 0.10): continue #if(shape > 0.8): # continue #else: #average area #radius2 = max(radius, np.sqrt(area_test/np.pi)) #shape = ComputeBranchSectionShape(cutPoly, point, size_range) writerline = vmtkscripts.vmtkSurfaceWriter() writerline.OutputFileName = "test_loop_{0}.vtp".format( pd_count) writerline.Input = cutPoly #ex.GetOutput() writerline.Execute() pd_count += 1 #if (radius2 <= 0.0): #radius2 = centerlines.GetPointData().GetArray("MaximumInscribedSphereRadius").GetTuple(cell.GetPointIds().GetId(k))[0] ##if ( radius2 > radius): ##radius = radius2 ##else: ##ratio = radius/radius2 #else: #print(length) clip_id = cell.GetPointIds().GetId(k) bifurcation_info[i]["clip_id"].append(clip_id) bifurcation_info[i]["cell_id"].append(k) break #return #t = [ 1 for i in bifurcation_info.keys() if len(bifurcation_info[i]) == 2] two_bif = False pd_count = 0 for cell in bifurcation_info: id_sorted = sorted(bifurcation_info[cell]["cell_id"]) if (len(bifurcation_info[cell]["cell_id"]) < 2): two_bif = False else: two_bif = True diff = bifurcation_info[cell]["cell_id"][0] - bifurcation_info[ cell]["cell_id"][1] if (abs(diff) < 2): # there is a problem if there less than two points print("houston we got a problem") clip_id = centerlines.GetCell(cell).GetPointIds().GetId(id_sorted[0]) clip_id_m1 = centerlines.GetCell(cell).GetPointIds().GetId( id_sorted[0] + 1) start_pt = centerlines.GetPoint(clip_id) surface_pt_id = locator_surf.FindClosestPoint(start_pt) # vector from pt(start_pt+1) - pt(start_pt) v_start = [ x - y for x, y in zip(centerlines.GetPoint(clip_id_m1), start_pt) ] v_ctr_start = centerlines.GetPointData().GetArray( "FrenetTangent").GetTuple(clip_id) v_normal_start = centerlines.GetPointData().GetArray( "FrenetNormal").GetTuple(clip_id) # want inward facing normals if (vtk.vtkMath.Dot(v_start, v_ctr_start) < 0.0): v_ctr_start = [-1.0 * x for x in v_ctr_start] #print(clip_tangent) plane1 = vtk.vtkPlane() plane1.SetOrigin(start_pt) plane1.SetNormal(v_ctr_start) #tree = vtk.vtkModifiedBSPTree() #tree.SetDataSet(surface_reference) #tree.BuildLocator() ##intersect the locator with the line #LineP0 = start_pt ## 200 points #radius_est = centerlines.GetPointData().GetArray("MaximumInscribedSphereRadius").GetTuple(clip_id)[0] ##radii increment is proportional to circumference ##distance between points #cnt_dist = 0.05 #n_radii = int(np.pi*2.0*radius_est/cnt_dist) #dt = radius_est*4.0*cnt_dist #estimate ray step from radius #dtheta = [0.0 + i*(359.0-0.0)/(n_radii-1) for i in range(n_radii)] #[0.0] #out_vector = (0.0,0.0,0.0) #tolerance = 0.0000001 #polylines = vtk.vtkCellArray() #cut_surface = vtk.vtkPolyData() #new_line = vtk.vtkPolyLine() #new_line.GetPointIds().SetNumberOfIds(len(dtheta)+1) #IntersectPointsList = vtk.vtkPoints() #loop_pts_list = vtk.vtkPoints() #IntersectCellsList = vtk.vtkIdList() #for idx, theta in enumerate(dtheta): #IntersectPoints = vtk.vtkPoints() #IntersectCells = vtk.vtkIdList() #code = 0 #count = 1 #rotate = vtk.vtkTransform() #rotate.RotateWXYZ(theta, v_ctr_start) #rotate.Update() ##print(dir(rotate)) ##trans_m = vtk.vtkMatrix4x4() ##rotate.GetMatrix(trans_m) #out_vector = rotate.TransformVector(v_normal_start) #LineP1 = [ c2 + count*dt*c1 for c2, c1 in zip(start_pt, out_vector)] ##print(v_normal_start, out_vector) #while ( code == 0 and count < 10000): #count += 1 #code = tree.IntersectWithLine(LineP0, LineP1, #tolerance, IntersectPoints, #IntersectCells) #LineP1 = [ c2 + count*dt*c1 for c2, c1 in zip(start_pt, out_vector)] #if(count > 10000 and code == 0): #print("no intersection") #continue #if (code != 0): #if(IntersectCells.GetNumberOfIds() > 1): #print(IntersectCells.GetNumberOfIds()) #pt = IntersectPoints.GetPoint(0) ##pt = [ c2 + dt*c1 for c2, c1 in zip(pt, out_vector)] # add some buffer, may not need it #new_pt_id = IntersectPointsList.InsertNextPoint(pt) #new_line.GetPointIds().SetId(idx, new_pt_id) #loop_pts_list.InsertNextPoint(LineP1) #IntersectCellsList.InsertNextId(IntersectCells.GetId(0)) ##print(IntersectPoints.GetPoint(0), IntersectCells.GetId(0) ) #new_line.GetPointIds().SetId(len(dtheta), 0) #print(IntersectPointsList.GetPoint(0)) #print(v_ctr_start, start_pt) #polylines.InsertNextCell(new_line) #cut_surface.SetPoints(IntersectPointsList) #cut_surface.SetLines(polylines) #writerline = vmtkscripts.vmtkSurfaceWriter() #writerline.OutputFileName = "test_loop_{0}.vtp".format(pd_count) #writerline.Input = cut_surface #writerline.Execute() cutter = vtk.vtkCutter() cutter.SetInputData(surface_reference) cutter.SetCutFunction(plane1) cutter.Update() extract = vtk.vtkPolyDataConnectivityFilter() extract.SetInputConnection(cutter.GetOutputPort()) extract.SetExtractionModeToClosestPointRegion() extract.SetClosestPoint(start_pt) extract.Update() loop = extract.GetOutput() weights = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] gencell = vtk.vtkGenericCell() cross_inter = [0.0, 0.0, 0.0] cross_edges = [0.0, 0.0, 0.0] cross_test = [0.0, 0.0, 0.0] test_pt = [0.0, 0.0, 0.0] thresh = 0.0 first_3tris = False for i in range(loop.GetNumberOfCells()): pt1 = loop.GetPoint(loop.GetCell(i).GetPointIds().GetId(0)) pt2 = loop.GetPoint(loop.GetCell(i).GetPointIds().GetId(1)) mid_pt = [(x + y) / 2.0 for x, y in zip(pt2, pt1)] direction = [x - y for x, y in zip(pt2, pt1)] cell_id = locator_cell.FindCell(mid_pt, 0.0001, gencell, test_pt, weights) cell_ = surface_reference.GetCell(cell_id) right = [] left = [] center = [] pt_list = [] for j in range(cell_.GetNumberOfPoints()): #get distance pt_list.append( surface_reference.GetPoint(cell_.GetPointIds().GetId(j))) dist = plane1.EvaluateFunction(pt_list[-1]) if (dist < -thresh): left.append(j) elif (dist > thresh): right.append(j) else: center.append(j) tag = "" if len(center) > 1: # don't do anything its already split on edge tag = "edge" print("edge") elif len(center) > 0: # split into two triangles pt = center[0] tag = "2_tris" else: tag = "3_tris" if (len(left) > 1): #print("left") pt = right[0] elif (len(right) > 1): pt = left[0] else: print("split triangle") edge1 = [x - y for x, y in zip(pt_list[(pt + 1) % 3], pt_list[pt])] edge2 = [x - y for x, y in zip(pt_list[(pt + 2) % 3], pt_list[pt])] vtk.vtkMath.Cross(edge1, edge2, cross_edges) vtk.vtkMath.Normalize(cross_edges) vtk.vtkMath.Cross(edge1, direction, cross_test) vtk.vtkMath.Normalize(cross_test) is_winding = vtk.vtkMath.Dot(cross_edges, cross_test) # switch the winding of the intersection points if (is_winding < 0.0): tmp = pt1 pt1 = pt2 pt2 = tmp if (tag == "3_tris"): if (first_3tris == False): first_3tris = True # first triangle #new_cell = vtk.vtkTriangle() #pts_id_list = [] #pt_id_1 = triangle_pts.InsertNextPoint(pt_list[pt]) #new_cell.GetPointIds().SetId(0, pt_id_1) #pt_id_2 = triangle_pts.InsertNextPoint(pt1) #new_cell.GetPointIds().SetId(1, pt_id_2) #pt_id_3 = triangle_pts.InsertNextPoint(pt2) #new_cell.GetPointIds().SetId(2, pt_id_3) #triangles.InsertNextCell(new_cell) triangle_pts = vtk.vtkPoints() quad_id_1 = triangle_pts.InsertNextPoint(pt2) quad_id_2 = triangle_pts.InsertNextPoint(pt1) quad_id_3 = triangle_pts.InsertNextPoint(pt_list[(pt + 1) % 3]) quad_id_4 = triangle_pts.InsertNextPoint(pt_list[(pt + 2) % 3]) pts_new_triangle = [] pt_id_2 = surface_reference.GetPoints().InsertNextPoint(pt1) pts_new_triangle.append( surface_reference.GetCell(cell_id).GetPointIds().GetId(pt)) pts_new_triangle.append(pt_id_2) surface_reference.GetPointData().GetArray( "Ids").InsertNextTuple([pt_id_2]) pt_id_2_old = surface_reference.GetCell( cell_id).GetPointIds().GetId((pt + 1) % 3) #surface_reference.GetCell(cell_id).GetPointIds().SetId((pt+1)%3, pt_id_2) pt_id_3 = surface_reference.GetPoints().InsertNextPoint(pt2) pts_new_triangle.append(pt_id_3) surface_reference.GetPointData().GetArray( "Ids").InsertNextTuple([pt_id_2]) pt_id_3_old = surface_reference.GetCell( cell_id).GetPointIds().GetId((pt + 2) % 3) #surface_reference.GetCell(cell_id).GetPointIds().SetId((pt+2)%3, pt_id_3) surface_reference.ReplaceCell(cell_id, len(pts_new_triangle), pts_new_triangle) # map polygon to reference mesh map_to = { quad_id_1: pt_id_3, quad_id_2: pt_id_2, quad_id_3: pt_id_2_old, quad_id_4: pt_id_3_old } npts = 4 polygon = vtk.vtkPolygon() polygon.GetPointIds().SetNumberOfIds(npts) polygon.GetPoints().SetNumberOfPoints(npts) polygon.GetPointIds().SetId(0, quad_id_1) polygon.GetPoints().SetPoint(0, triangle_pts.GetPoint(quad_id_1)) polygon.GetPointIds().SetId(1, quad_id_2) polygon.GetPoints().SetPoint(1, triangle_pts.GetPoint(quad_id_2)) polygon.GetPointIds().SetId(2, quad_id_3) polygon.GetPoints().SetPoint(2, triangle_pts.GetPoint(quad_id_3)) polygon.GetPointIds().SetId(3, quad_id_4) polygon.GetPoints().SetPoint(3, triangle_pts.GetPoint(quad_id_4)) quad_ids = vtk.vtkIdList() polygon.Triangulate(quad_ids) numPts = quad_ids.GetNumberOfIds() numSimplices = numPts // 3 triPts = [0, 0, 0] triPts_map = [0, 0, 0] #print(numSimplices, numPts for j in range(numSimplices): for k in range(3): triPts[k] = polygon.GetPointIds().GetId( quad_ids.GetId(int(3 * j + k))) triPts_map[k] = map_to[triPts[k]] #triangles.InsertNextCell(3, triPts) cell_id_new = surface_reference.GetPolys().InsertNextCell( 3, triPts_map) surface_reference.GetCellData().GetArray( "Ids").InsertNextTuple([cell_id_new]) #surface_reference.Modified() #print("hello") #if ( tag == "2_tris"): ## doesnt' work well ## for collapse of intersection line on #new_cell = vtk.vtkTriangle() #pts_id_list = [] #pt_id_1 = triangle_pts.InsertNextPoint(pt_list[pt]) #new_cell.GetPointIds().SetId(0, pt_id_1) #pt_id_2 = triangle_pts.InsertNextPoint(pt_list[(pt+1)%3]) #new_cell.GetPointIds().SetId(1, pt_id_2) #pt_id_3 = triangle_pts.InsertNextPoint(pt2) #new_cell.GetPointIds().SetId(2, pt_id_3) #triangles.InsertNextCell(new_cell) #new_cell = vtk.vtkTriangle() #new_cell.GetPointIds().SetId(0, pt_id_1) #new_cell.GetPointIds().SetId(1, pt_id_3) #pt_id_4 = triangle_pts.InsertNextPoint(pt_list[(pt+2)%3]) #new_cell.GetPointIds().SetId(2, pt_id_4) #triangles.InsertNextCell(new_cell) #triangle_pd.SetPoints(triangle_pts) #triangle_pd.SetPolys(triangles) #pass_ = vtk.vtkPassArrays() #pass_.SetInputData(surface_reference) #pass_.RemoveArraysOn() #pass_.RemoveCellDataArray("Ids") #pass_.RemoveCellDataArray("Normals") #pass_.RemovePointDataArray("Ids") #pass_.RemovePointDataArray("Normals") ##pass_.ClearPointDataArrays() ##pass_.ClearCellDataArrays() #pass_.Update() #geom = vtk.vtkGeometryFilter() #geom.SetInputConnection(pass_.GetOutputPort()) #geom.Update() #normalsFilter2 = vmtkscripts.vmtkSurfaceNormals() #normalsFilter2.ComputeCellNormals = 1 #normalsFilter2.Surface = surface_reference #normalsFilter2.NormalsArrayName = 'Normals' #normalsFilter2.Execute() #writer = vmtkscripts.vmtkSurfaceWriter() #writer.OutputFileName = "test_file_{0}.vtp".format(pd_count) #writer.Input = surface_reference #geom.GetOutput() #triangle_pd #extract.GetOutput() #writer.Execute() pd_count += 1 #print("yp") surface_reference.Modified() #print("zzz") surface_reference.BuildCells() surface_reference.BuildLinks() #print("yppp") locator_surf = vtk.vtkPointLocator() locator_surf.SetDataSet(surface_reference) locator_surf.BuildLocator() #print("ydddp") locator_cell = vtk.vtkCellLocator() locator_cell.SetDataSet(surface_reference) locator_cell.BuildLocator() #return print(bifurcation_info) #return normalsFilter2 = vmtkscripts.vmtkSurfaceNormals() normalsFilter2.ComputeCellNormals = 1 normalsFilter2.Surface = surface_reference normalsFilter2.NormalsArrayName = 'Normals' normalsFilter2.Execute() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file writer.Input = normalsFilter2.Surface writer.Execute()
def Execute(args): print("evaluate centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() centerlines = reader_ctr.Surface locator_cell = vtk.vtkPointLocator() locator_cell.SetDataSet(centerlines) locator_cell.BuildLocator() reader_br = vmtkscripts.vmtkSurfaceReader() reader_br.InputFileName = args.boundary_reference reader_br.Execute() boundary_reference = reader_br.Surface terminal_pts = boundary_reference.GetNumberOfPoints() avg_area = vtk.vtkDoubleArray() avg_area.SetName("avg_crosssection") avg_area.SetNumberOfComponents(1) avg_area.SetNumberOfTuples(terminal_pts) #for j in range(centerlines.GetCellData().GetNumberOfArrays()): #new_array = centerlines.GetCellData().GetArray(j) #array_name = centerlines.GetCellData().GetArrayName(j) ##new_array.SetNumberOfTuples(terminal_pts) #boundary_reference.GetPointData().AddArray(new_array) ##boundary_reference.GetPointData().GetArray(array_name).SetNumberOfTuples(terminal_pts) #writer = vmtkscripts.vmtkSurfaceWriter() #writer.OutputFileName = "test_out.vtp" #writer.Input = boundary_reference #writer.Execute() for i in range(terminal_pts): pt = boundary_reference.GetPoint(i) #B ctr_ptId = locator_cell.FindClosestPoint(pt) cell_ids_list = vtk.vtkIdList() centerlines.GetPointCells(ctr_ptId, cell_ids_list) if (cell_ids_list.GetNumberOfIds() > 1): print("something has gone wrong, this is a bifurcation point") else: new_tuple = centerlines.GetCellData().GetArray( "avg_crosssection").GetTuple(cell_ids_list.GetId(0)) avg_area.SetTuple(i, new_tuple) #for j in range(centerlines.GetCellData().GetNumberOfArrays()): #print(cell_ids_list.GetId(0)) #new_tuple = centerlines.GetCellData().GetArray(j).GetTuple(cell_ids_list.GetId(0)) #array_name = centerlines.GetCellData().GetArrayName(j) ##print(array_name) #boundary_reference.GetPointData().GetArray(array_name).SetTuple(i, new_tuple) boundary_reference.GetPointData().AddArray(avg_area) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file writer.Input = boundary_reference writer.Execute()
def vmtksurfacewriter(polydata, filename): print "Writing", filename writer = vmtkscripts.vmtkSurfaceWriter() writer.Surface = polydata writer.OutputFileName = filename writer.Execute()
def Execute(args): print("get average along line probes") reader_lines = vmtkscripts.vmtkSurfaceReader() reader_lines.InputFileName = args.lines_file reader_lines.Execute() lines_surface = reader_lines.Surface n_cells = lines_surface.GetNumberOfCells() n_pts = lines_surface.GetCell(0).GetNumberOfPoints() lines = np.empty((n_cells, n_pts)) pts = np.empty((n_cells, 3)) da = lines_surface.GetPointData().GetArray("NRRDImage") for i in range(n_cells): cellids = lines_surface.GetCell(i).GetPointIds() #n_pts = cell.GetNumberOfPoints() for j in range(n_pts): if (j == n_pts // 2): pts[i, :] = np.array(lines_surface.GetPoint(cellids.GetId(j))) lines[i, j] = lines_surface.GetPointData().GetArray( "NRRDImage").GetTuple(cellids.GetId(j))[0] ln_avg = np.average(lines, axis=1) ln_std = np.std(lines, axis=1, ddof=1) ln_skew = skew(lines, axis=1, bias=False) avg_min = ln_avg.min() ln_avg_norm = (ln_avg + avg_min) / (ln_avg.max() + avg_min) # get weighted average x = np.linspace(-args.slice_thickness, args.slice_thickness, lines.shape[1]) std = args.slice_thickness / 2.0 mean = 0.0 dist = 1.0 / np.sqrt(2.0 * np.pi * std**2) * np.exp(-(x - mean)**2 / (2.0 * std**2)) ln_avg_weight = np.average(lines, axis=1, weights=dist) reader_surface = vmtkscripts.vmtkSurfaceReader() reader_surface.InputFileName = args.surface_file reader_surface.Execute() Surface = reader_surface.Surface #Create the tree pointLocator = vtk.vtkPointLocator() pointLocator.SetDataSet(Surface) pointLocator.BuildLocator() array = vtk.vtkDoubleArray() array.SetNumberOfComponents(n_pts) array.SetName("rawImageSamples") array.SetNumberOfTuples(n_cells) avg = vtk.vtkDoubleArray() avg.SetNumberOfComponents(1) avg.SetName("avgSample") avg.SetNumberOfTuples(n_cells) avg_norm = vtk.vtkDoubleArray() avg_norm.SetNumberOfComponents(1) avg_norm.SetName("normalized") avg_norm.SetNumberOfTuples(n_cells) stddev = vtk.vtkDoubleArray() stddev.SetNumberOfComponents(1) stddev.SetName("stddev") stddev.SetNumberOfTuples(n_cells) skewness = vtk.vtkDoubleArray() skewness.SetNumberOfComponents(1) skewness.SetName("skewness") skewness.SetNumberOfTuples(n_cells) weighted_avg = vtk.vtkDoubleArray() weighted_avg.SetNumberOfComponents(1) weighted_avg.SetName("weighted_average") weighted_avg.SetNumberOfTuples(n_cells) for i in range(n_cells): surf_id = pointLocator.FindClosestPoint(pts[i]) #print(ln_avg.shape) avg.SetValue(surf_id, ln_avg[i]) array.SetTuple(surf_id, list(lines[i, :])) avg_norm.SetValue(surf_id, ln_avg_norm[i]) stddev.SetValue(surf_id, ln_std[i]) skewness.SetValue(surf_id, ln_skew[i]) weighted_avg.SetValue(surf_id, ln_avg_weight[i]) Surface.GetPointData().AddArray(avg) Surface.GetPointData().AddArray(array) Surface.GetPointData().AddArray(avg_norm) Surface.GetPointData().AddArray(stddev) Surface.GetPointData().AddArray(skewness) Surface.GetPointData().AddArray(weighted_avg) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.file_out writer.Input = Surface writer.Execute()
def Execute(args): print("clip surface") mesh_reader = vmtkscripts.vmtkMeshReader() mesh_reader.InputFileName = args.mesh_file mesh_reader.Execute() mesh2surf = vmtkscripts.vmtkMeshToSurface() mesh2surf.Mesh = mesh_reader.Mesh mesh2surf.CleanOutput = 0 mesh2surf.Execute() scale_cfd = vmtkscripts.vmtkSurfaceScaling() scale_cfd.ScaleFactor = args.scale # meters to mm scale_cfd.Surface = mesh2surf.Surface scale_cfd.Execute() surface = vtk.vtkPolyData() surface.DeepCopy(scale_cfd.Surface) reader_trim = vmtkscripts.vmtkSurfaceReader() reader_trim.InputFileName = args.polydata_trim reader_trim.Execute() br_trim = reader_trim.Surface reader_ext = vmtkscripts.vmtkSurfaceReader() reader_ext.InputFileName = args.polydata_ext reader_ext.Execute() br_ext = reader_ext.Surface # have to make sure that they both have the same number of GetNumberOfPoints assert br_trim.GetNumberOfPoints() == br_ext.GetNumberOfPoints() locator = vtk.vtkPointLocator() locator.SetDataSet(br_trim) locator.BuildLocator() point_ext = [0.0, 0.0, 0.0] pt_cross = [0.0, 0.0, 0.0] pt_dot = 0.0 count = 0 for trim_id in range(br_ext.GetNumberOfPoints()): # get extension point point_ext = br_ext.GetPoint(trim_id) #closest trim point point_trim_id = locator.FindClosestPoint(point_ext) point_trim = br_trim.GetPoint(point_trim_id) # check that the points are close to the same direction pt_trim_normal = br_trim.GetPointData().GetArray( "BoundaryNormals").GetTuple(point_trim_id) pt_ext_normal = br_ext.GetPointData().GetArray( "BoundaryNormals").GetTuple(trim_id) #print(pt_trim_normal, pt_ext_normal) pt_dot = vtk.vtkMath.Dot(pt_trim_normal, pt_ext_normal) #vtk.vtkMath.Cross(pt_trim_normal, pt_ext_normal, pt_cross) #print(pt_dot, vtk.vtkMath.Norm(pt_cross))#, pt_cross) if (pt_dot < 0.95): print("help the vectors aren't colinear") assert pt_dot > .95 v = np.array(point_ext) - np.array(point_trim) #pt1 - pt2 v_mag = np.linalg.norm(v) n = v / v_mag # print("should be 1.0", np.linalg.norm(n), n) b1, b2 = hughes_moeller(n) #orthogonal basis #Get maximum radius box_radius = br_ext.GetPointData().GetArray("BoundaryRadius").GetTuple( trim_id) box_radius_trim = br_trim.GetPointData().GetArray( "BoundaryRadius").GetTuple(point_trim_id) #print(box_radius_trim, box_radius) extra_room = args.margin extra_z = 0.0 r_max = extra_room * max([box_radius[0], box_radius_trim[0] ]) # max radius z_max = extra_room * v_mag #create transformation matrix R = np.zeros((4, 4), dtype=np.float64) R[:3, 0] = b1 #x R[:3, 1] = b2 #y R[:3, 2] = n #z R[:3, 3] = np.array(point_trim) # the beginning of the clip R[3, 3] = 1.0 trans_matrix = vtk.vtkTransform() trans_inverse = vtk.vtkTransform() trans_matrix.SetMatrix(list(R.ravel())) #print(trans_matrix.GetMatrix()) trans_inverse.DeepCopy(trans_matrix) trans_inverse.Inverse() # point to define bounds dims_min = [-r_max, -r_max, -extra_z * z_max] dims_max = [r_max, r_max, z_max] planes = vtk.vtkBox() planes.SetBounds(dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2]) planes.SetTransform(trans_inverse) clipper = vtk.vtkTableBasedClipDataSet() clipper.SetInputData(surface) clipper.SetClipFunction(planes) clipper.InsideOutOff() #clipper.SetMergeTolerance(1.0E-6) clipper.Update() #print(clipper.GetMergeTolerance()) surface = clipper.GetOutput() #test = vtk.vtkCubeSource() #test.SetBounds (dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2]) #trans_cube = vtk.vtkTransformPolyDataFilter() #trans_cube.SetInputConnection(test.GetOutputPort()) #trans_cube.SetTransform(trans_matrix) #trans_cube.Update() #writer2 = vmtkscripts.vmtkSurfaceWriter() #writer2.OutputFileName = os.path.join(os.path.split(args.out_file)[0], "test_clip_box_{0}.vtp".format(count)) #writer2.Input = trans_cube.GetOutput() #writer2.Execute() count += 1 geom = vtk.vtkGeometryFilter() geom.SetInputData(surface) geom.Update() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file writer.Input = geom.GetOutput() writer.Execute()
def Execute(args): print("evaluate centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() print(args.clean_ctr) if(args.clean_ctr): cleaner = vtk.vtkCleanPolyData() cleaner.PointMergingOn() cleaner.SetInputData(reader_ctr.Surface) cleaner.Update() centerlines = cleaner.GetOutput() else: centerlines = reader_ctr.Surface centerlines.BuildLinks() centerlines.BuildCells() # calculate length for each segment # seems to be some error in prevous calculation for i in range(centerlines.GetNumberOfCells()): cell = centerlines.GetCell(i) length_ = 0.0 prevPoint = cell.GetPoints().GetPoint(0) for j in range(cell.GetNumberOfPoints()): point = cell.GetPoints().GetPoint(j) length_ += vtk.vtkMath.Distance2BetweenPoints(prevPoint,point)**0.5 prevPoint = point centerlines.GetCellData().GetArray("length").SetTuple(i, [length_]) #writer2 = vmtkscripts.vmtkSurfaceWriter() #writer2.OutputFileName = "centerlines_test.vtp" #writer2.Input = centerlines #writer2.Execute() reader_br = vmtkscripts.vmtkSurfaceReader() reader_br.InputFileName = args.surface reader_br.Execute() #if (reader_br.Surface.GetPointData().GetNormals() == None): #normalsFilter = vmtkscripts.vmtkSurfaceNormals() #normalsFilter.ComputeCellNormals = 1 #normalsFilter.Surface = reader_br.Surface #normalsFilter.NormalsArrayName = 'Normals' #normalsFilter.Execute() #surface_reference = normalsFilter.Surface #else: surface_reference = reader_br.Surface locator_surf = vtk.vtkPointLocator() locator_surf.SetDataSet(surface_reference) locator_surf.BuildLocator() locator_cell = vtk.vtkCellLocator() locator_cell.SetDataSet(surface_reference) locator_cell.BuildLocator() cell_Ids = vtk.vtkIdList() outputLines = vtk.vtkCellArray() output = vtk.vtkPolyData() triangles = vtk.vtkCellArray() triangle_pd = vtk.vtkPolyData() triangle_pts = vtk.vtkPoints() lengthArray = vtk.vtkDoubleArray() lengthArray.SetName("length") lengthArray.SetNumberOfComponents(1) pts_ids = vtk.vtkIdList() factor = 1.0 factor2 = 2.0 pd_count = 0 size_range = [0.0, 0.0] mid_points = vtk.vtkPoints() vertex = vtk.vtkCellArray() bifurcation_info = {} for i in range(centerlines.GetNumberOfCells()): bifurcation_info[i] = {"clip_id": [], "cell_pt_id": [], "mid_pt": [], "step":[], "less_length": 0.0} cell = centerlines.GetCell(i) if cell.GetCellType() not in (vtk.VTK_POLY_LINE, vtk.VTK_LINE): continue n_cell_pts = cell.GetNumberOfPoints() start_end_pt = [0, n_cell_pts-1] cell_length_half = centerlines.GetCellData().GetArray("length").GetTuple(i)[0]/2.0 for j in start_end_pt: pt_id_pd = cell.GetPointIds().GetId(j) centerlines.GetPointCells(pt_id_pd, cell_Ids) if (cell_Ids.GetNumberOfIds() > 1): radius = centerlines.GetPointData().GetArray("MaximumInscribedSphereRadius").GetTuple(pt_id_pd)[0] length = 0.0 radius2 = 0.0 prev_point = centerlines.GetPoint(pt_id_pd) if( j == start_end_pt[0]): step = 1 stop = start_end_pt[-1] else: step = -1 stop = -1 for k in range(j, stop, step): point = centerlines.GetPoint(cell.GetPointIds().GetId(k)) length += vtk.vtkMath.Distance2BetweenPoints(prev_point,point)**0.5 prev_point = point if (length > (factor*radius + factor2*radius2)): #print(length) pl_vec = centerlines.GetPointData().GetArray("FrenetTangent").GetTuple(cell.GetPointIds().GetId(k)) pl = vtk.vtkPlane() pl.SetOrigin(point) pl.SetNormal(pl_vec) cut = vtk.vtkCutter() cut.SetInputData(surface_reference) cut.SetCutFunction(pl) cut.Update() ex = vtk.vtkPolyDataConnectivityFilter() ex.SetInputConnection(cut.GetOutputPort()) #ex.SetExtractionModeToAllRegions() ex.SetExtractionModeToClosestPointRegion() ex.SetClosestPoint(point) ex.Update() lp = ex.GetOutput() close_cell(lp) cutStrips = vtk.vtkStripper() # Forms loops (closed polylines) from cutter cutStrips.SetInputData(lp) cutStrips.Update() cutPoly = vtk.vtkPolyData() # This trick defines polygons as polyline loop cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints()) cutPoly.SetPolys((cutStrips.GetOutput()).GetLines()) area_test = ComputePolygonArea(cutPoly) size_ratio = area_test/(np.pi*radius**2) #print(area_test, radius, size_ratio) #writerline = vmtkscripts.vmtkSurfaceWriter() #writerline.OutputFileName = "test_loop_{0}.vtp".format(pd_count) #writerline.Input = cutPoly #ex.GetOutput() #writerline.Execute() #pd_count += 1 if (length < cell_length_half): if(size_ratio > 2.0 ): continue cv, offset, shape = ComputeBranchSectionShape(cutPoly, point) if(cv > 0.2): # standard deviation / mean continue if(offset > 0.10): # centroid of slice vs centerline point continue #if(shape > 0.8): # continue #writerline = vmtkscripts.vmtkSurfaceWriter() #writerline.OutputFileName = "test_loop_{0}.vtp".format(pd_count) #writerline.Input = cutPoly #ex.GetOutput() #writerline.Execute() #pd_count += 1 #print(length) clip_id = cell.GetPointIds().GetId(k) bifurcation_info[i]["clip_id"].append(clip_id) bifurcation_info[i]["cell_pt_id"].append(k) bifurcation_info[i]["step"].append(step) bifurcation_info[i]["less_length"] += length tmp_idx = k break midway_length = 0.0 prev_point = centerlines.GetPoint(pt_id_pd) print("hello") for k in range(tmp_idx, stop, step): if k == 1198: print(k) point = centerlines.GetPoint(cell.GetPointIds().GetId(k)) midway_length += vtk.vtkMath.Distance2BetweenPoints(prev_point, point)**0.5 prev_point = point if (midway_length >= cell_length_half): bifurcation_info[i]["mid_pt"].append(point) pt_id = mid_points.InsertNextPoint(point) vertex.InsertNextCell(1, [pt_id]) mid_idx = k break mid_point_pd = vtk.vtkPolyData() mid_point_pd.SetPoints(mid_points) mid_point_pd.SetVerts(vertex) writerline = vmtkscripts.vmtkSurfaceWriter() writerline.OutputFileName = "test_vertex_{0}.vtp".format(0) writerline.Input = mid_point_pd writerline.Execute() #return tree = vtk.vtkModifiedBSPTree() tree.SetDataSet(surface_reference) tree.BuildLocator() #t = [ 1 for i in bifurcation_info.keys() if len(bifurcation_info[i]) == 2] two_bif = False pd_count = 0 avg_x_area = vtk.vtkDoubleArray() avg_x_area.SetName("avg_crosssection") avg_x_area.SetNumberOfComponents(1) avg_x_area.SetNumberOfTuples(centerlines.GetNumberOfCells()) avg_x_area.Fill(-1.0) aspect_ratio = vtk.vtkDoubleArray() aspect_ratio.SetName("aspect_ratio") aspect_ratio.SetNumberOfComponents(1) aspect_ratio.SetNumberOfTuples(centerlines.GetNumberOfCells()) aspect_ratio.Fill(-1.0) vol_array = vtk.vtkDoubleArray() vol_array.SetName("volume") vol_array.SetNumberOfComponents(1) vol_array.SetNumberOfTuples(centerlines.GetNumberOfCells()) vol_array.Fill(-1.0) len_array = vtk.vtkDoubleArray() len_array.SetName("length_wo_bifurcation") len_array.SetNumberOfComponents(1) len_array.SetNumberOfTuples(centerlines.GetNumberOfCells()) len_array.Fill(-1.0) append = vtk.vtkAppendPolyData() for cell_id in bifurcation_info: id_sorted = sorted(bifurcation_info[cell_id]["cell_pt_id"]) step_direction = [x for _,x in sorted(zip(bifurcation_info[cell_id]["cell_pt_id"], bifurcation_info[cell_id]["step"]))] #print(step_direction) if (len(bifurcation_info[cell_id]["cell_pt_id"]) < 2): two_bif = False else: two_bif = True diff = bifurcation_info[cell_id]["cell_pt_id"][0] - bifurcation_info[cell_id]["cell_pt_id"][1] if(abs(diff) < 2): # there is a problem if there less than two points print("houston we got a problem") if (not two_bif): clip_id = centerlines.GetCell(cell_id).GetPointIds().GetId(id_sorted[0]) clip_id_m1 = centerlines.GetCell(cell_id).GetPointIds().GetId(id_sorted[0]+step_direction[0]) start_pt = centerlines.GetPoint(clip_id) surface_pt_id = locator_surf.FindClosestPoint(start_pt) # vector from pt(start_pt+1) - pt(start_pt) v_start = [ x - y for x,y in zip(centerlines.GetPoint(clip_id_m1), start_pt)] v_ctr_start = centerlines.GetPointData().GetArray("FrenetTangent").GetTuple(clip_id) v_normal_start = centerlines.GetPointData().GetArray("FrenetNormal").GetTuple(clip_id) # want inward facing normals if (vtk.vtkMath.Dot(v_start, v_ctr_start) < 0.0): v_ctr_start = [-1.0*x for x in v_ctr_start] #print(clip_tangent) plane1 = vtk.vtkPlane() plane1.SetOrigin(start_pt) plane1.SetNormal(v_ctr_start) seamFilter = vtkvmtk.vtkvmtkTopologicalSeamFilter() seamFilter.SetInputData(surface_reference) seamFilter.SetClosestPoint(surface_reference.GetPoint(surface_pt_id)) seamFilter.SetSeamScalarsArrayName("SeamScalars") seamFilter.SetSeamFunction(plane1) clipper = vtk.vtkClipPolyData() clipper.SetInputConnection(seamFilter.GetOutputPort()) clipper.GenerateClipScalarsOff() clipper.GenerateClippedOutputOn() connectivity = vtk.vtkPolyDataConnectivityFilter() connectivity.SetInputConnection(clipper.GetOutputPort()) connectivity.SetExtractionModeToClosestPointRegion() surface_mid_pt = locator_surf.FindClosestPoint(bifurcation_info[cell_id]["mid_pt"][0]) connectivity.SetClosestPoint(surface_reference.GetPoint(surface_mid_pt)) surfaceCleaner = vtk.vtkCleanPolyData() surfaceCleaner.SetInputConnection(connectivity.GetOutputPort()) surfaceCleaner.Update() surfaceTriangulator = vtk.vtkTriangleFilter() surfaceTriangulator.SetInputConnection(surfaceCleaner.GetOutputPort()) surfaceTriangulator.PassLinesOff() surfaceTriangulator.PassVertsOff() surfaceTriangulator.Update() capper = vmtkscripts.vmtkSurfaceCapper() capper.Surface = surfaceTriangulator.GetOutput() capper.Method = "simple" capper.Interactive = 0 capper.Execute() get_prop = vtk.vtkMassProperties() get_prop.SetInputData(capper.Surface) get_prop.Update() volume = get_prop.GetVolume() new_length = centerlines.GetCellData().GetArray("length").GetTuple(cell_id)[0] - bifurcation_info[cell_id]["less_length"] average_area = volume/new_length avg_x_area.SetTuple(cell_id, [average_area]) aspect_ratio.SetTuple(cell_id, [average_area/new_length]) vol_array.SetTuple(cell_id, [volume]) len_array.SetTuple(cell_id, [new_length]) append.AddInputData(capper.Surface) append.Update() #print(new_length, centerlines.GetCellData().GetArray("length").GetTuple(cell_id)[0], bifurcation_info[cell_id]["less_length"]) #pd_count += 1 writerline = vmtkscripts.vmtkSurfaceWriter() writerline.OutputFileName = args.out_file writerline.Input = append.GetOutput() writerline.Execute() #print( bifurcation_info) centerlines.GetCellData().AddArray(avg_x_area) centerlines.GetCellData().AddArray(aspect_ratio) centerlines.GetCellData().AddArray(vol_array) centerlines.GetCellData().AddArray(len_array) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_segments writer.Input = centerlines writer.Execute()
def Execute(self): print("Get Surface Boundaries") reader = vmtkscripts.vmtkSurfaceReader() reader.InputFileName = self.InputFile reader.Execute() self.Surface = reader.Surface #vtkPolyData #Define variables used by the algorithm inpts = vtk.vtkPoints() inPolys = vtk.vtkCellArray() # ints of vtkIdType # newPts numPts, newId, cellId #Get input points, polys and set the up in the vtkPolyData mesh inpts = self.Surface.GetPoints() inPolys = self.Surface.GetPolys() self.mesh.SetPoints(inpts) self.mesh.SetPolys(inPolys) #Build Links in the mesh to be able to perform complex polydata processes self.mesh.BuildLinks() #Get the number of Polys for scalar allocation numPolys = self.Surface.GetNumberOfPolys() numPts = self.Surface.GetNumberOfPoints() #Check the input to make sure it is there if (numPolys < 1): raise RuntimeError("No Input") #Set up Region scalar for each surface self.NewScalars.SetNumberOfTuples(numPolys) #Set up Feature Edges for Boundary Edge Detection inputCopy = self.Surface.NewInstance() inputCopy.ShallowCopy(self.Surface) #Set the Data to hold onto given Point Markers inputCopy.GlobalReleaseDataFlagOff() self.boundaries.SetInputData(inputCopy) self.boundaries.BoundaryEdgesOff() #(self.BoundaryEdges) self.boundaries.ManifoldEdgesOff() #(self.ManifoldEdges) self.boundaries.NonManifoldEdgesOff() #(self.NonManifoldEdges) self.boundaries.FeatureEdgesOn() #(self.FeatureEdges) self.boundaries.SetFeatureAngle(self.FeatureAngle) #inputCopy.Delete() self.boundaries.Update() # Set the boundary lines self.BoundaryLines.DeepCopy(self.boundaries.GetOutput()) # Initialize the arrays to be used in the flood fills self.SetBoundaryArrays() print("Starting Boundary Face Separation") # Set Region value of each cell to be zero initially reg = 0 for cellId in range(numPolys): self.NewScalars.InsertValue(cellId, reg) #Go through each cell and perfrom region identification proces #print(numPolys) for cellId in range(numPolys): #if(cellId % 1000 == 0): #print(cellId) #Check to make sure the value of the region at self cellId hasn't been set if (self.NewScalars.GetValue(cellId) == 0): reg += 1 self.CheckCells.InsertNextId(cellId) #Call function to find all cells within certain region self.FindBoundaryRegion(reg, 1) #print("party") self.CheckCells.Reset() self.CheckCells2.Reset() self.CheckCellsCareful.Reset() self.CheckCellsCareful2.Reset() # Check to see if anything left extraregion = 0 for cellId in range(numPolys): if (self.checked.GetValue(cellId) == 0 or self.checkedcarefully.GetValue(cellId == 0)): self.NewScalars.InsertValue(cellId, reg + 1) self.AddCellArea(cellId, area) extraregion = 1 if (extraregion): print("I am incrementing region") reg += 1 #Copy all the input geometry and data to the output output.SetPoints(inpts) output.SetPolys(inPolys) output.GetPointData().PassData(input.GetPointData()) output.GetCellData().PassData(input.GetCellData()) #Add the new scalars array to the output self.NewScalars.SetName(self.RegionIdsArrayName) output.GetCellData().AddArray(self.NewScalars) output.GetCellData().SetActiveScalars(self.RegionIdsArrayName) # If extracting largets region, get it out if (self.ExtractLargestRegion): maxVal = 0.0 maxRegion = -1 for i in range(reg): if (self.RegionAreas.GetValue(i) > maxVal): maxVal = self.RegionAreas.GetValue(i) maxRegion = i + 1 thresholder = vtk.vtkThreshold() thresholder.SetIntputData(output) thresholder.SetInputArrayToProcess(0, 0, 0, 1, self.RegionIdsArrayName) thresholder.ThresholdBetween(maxRegion, maxRegion) thresholder.Update() # Check to see if the result has points, don't run surface filter if (thresholder.GetOutput().GetNumberOfPoints() == 0): raise RuntimeError("vtkThreshold Output has no points") #Convert unstructured grid to polydata surfacer = vtk.vtkDataSetSurfaceFilter() surfacer.SetInputData(thresholder.GetOutput()) surfacer.Update() #Set the final pd output.DeepCopy(surfacer.GetOutput()) # Total number of regions self.NumberOfRegions = reg writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = self.OutputFile writer.Input = output writer.Execute()
def Execute(args): print("clip surface") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() centerlines = reader_ctr.Surface reader_surface = vmtkscripts.vmtkSurfaceReader() reader_surface.InputFileName = args.surface_file reader_surface.Execute() input_surface = reader_surface.Surface dx = args.slice_thickness # only get the first three centroid = [float(i) for i in args.centroid.strip(" ").split(",")][0:3] neck_centroid = np.array(centroid) n_pts = centerlines.GetNumberOfPoints() pt1 = np.array(centerlines.GetPoint(0)) # start point pt2 = np.array(centerlines.GetPoint(n_pts - 1)) # end point #print(pt1, pt2) v = pt2 - pt1 #pt1 - pt2 v_mag = np.linalg.norm(v) n = v / v_mag print("should be 1.0", np.linalg.norm(n), n) b1, b2 = hughes_moeller(n) #orthogonal basis #Get maximum radius radius_range = [0.0, 0.0] centerlines.GetPointData().GetArray( "MaximumInscribedSphereRadius").GetRange(radius_range, 0) print(radius_range) r_max = 2 * radius_range[-1] # max radius #https://en.wikipedia.org/wiki/Vector_projection # get starting point from centroid by projecting centroid onto normal direction neck_projection = np.dot(neck_centroid - pt1, n) * n neck_start_pt = pt1 + neck_projection print(neck_start_pt) #create transformation matrix R = np.zeros((4, 4), dtype=np.float64) R[:3, 0] = b1 #x R[:3, 1] = b2 #y R[:3, 2] = n #z R[:3, 3] = neck_start_pt R[3, 3] = 1.0 trans_matrix = vtk.vtkTransform() trans_inverse = vtk.vtkTransform() trans_matrix.SetMatrix(list(R.ravel())) print(trans_matrix.GetMatrix()) trans_inverse.DeepCopy(trans_matrix) trans_inverse.Inverse() count = 0 # slice along normal a1 = r_max #*b1 a2 = r_max #*b2 start_pt = np.copy(neck_start_pt) result = itertools.cycle([(1., 1.), (-1., 1.), (-1., -1.), (1., -1.)]) end_pt = 0.0 #slice until there some reasonable overlap at the end while (np.linalg.norm(neck_projection + (count - 0.5) * dx * n) < v_mag): print(np.linalg.norm(neck_projection + (count - 0.5) * dx * n), v_mag) step_dx = count * dx * n for i in range(4): box_dir = next(result) # point to define bounds #end_pt = start_pt + box_dir[0]*a1 + box_dir[1]*a2 + step_dx dims = np.array( [[box_dir[0] * r_max, box_dir[1] * r_max, (count + 1) * dx], [0.0, 0.0, count * dx]]) dims_min = list(dims.min(axis=0)) dims_max = list(dims.max(axis=0)) print(dims_min, dims_max) #planes = vtk.vtkBox() #planes.SetBounds (dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2]) #planes.SetTransform(trans_inverse) surface = vtk.vtkPolyData() surface.DeepCopy(input_surface) #surface = Input for j in range(3): for k in range(2): plane = vtk.vtkPlane() normal = [0.0, 0.0, 0.0] if (k == 0): normal[j] = -1.0 plane.SetOrigin(dims_min) else: normal[j] = 1.0 plane.SetOrigin(dims_max) plane.SetNormal(normal) plane.SetTransform(trans_inverse) #plane.SetTransform(trans_matrix) clipper = vtk.vtkTableBasedClipDataSet() clipper.SetInputData(surface) clipper.SetClipFunction(plane) #clipper.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION) clipper.InsideOutOn() #clipper.SetMergeTolerance(1.0E-6) clipper.Update() #print(clipper.GetMergeTolerance()) surface = clipper.GetOutput() geom = vtk.vtkGeometryFilter() geom.SetInputData(surface) geom.Update() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = os.path.join( args.out_dir, "{0}_{1}_quad_{2}.vtp".format(args.out_file, count, i)) writer.Input = geom.GetOutput() writer.Execute() if (count == 1): test = vtk.vtkCubeSource() test.SetBounds(dims_min[0], dims_max[0], dims_min[1], dims_max[1], dims_min[2], dims_max[2]) trans_cube = vtk.vtkTransformPolyDataFilter() trans_cube.SetInputConnection(test.GetOutputPort()) trans_cube.SetTransform(trans_matrix) trans_cube.Update() writer2 = vmtkscripts.vmtkSurfaceWriter() writer2.OutputFileName = os.path.join( args.out_dir, "{0}_{1}_quad{2}_box.vtp".format(args.out_file, count, i)) writer2.Input = trans_cube.GetOutput() writer2.Execute() count += 1
centerlineviewer.Legend = 1 centerlineviewer.Execute() branchClipper = vmtkscripts.vmtkBranchClipper() branchClipper.Centerlines = centerlines.Centerlines branchClipper.Surface = readSurface.GetOutput() branchClipper.Execute() branchMetrics = vmtkscripts.vmtkBranchMetrics() branchMetrics.Centerlines = branchClipper.Centerlines branchMetrics.Surface = branchClipper.Surface branchMetrics.AbscissasArrayName = 'Abscissas' branchMetrics.ComputeAngularMetric = 0 branchMetrics.Execute() surfaceWriter = vmtkscripts.vmtkSurfaceWriter() surfaceWriter.Surface = branchMetrics.Surface surfaceWriter.Format = 'vtkxml' surfaceWriter.Mode = 'ascii' surfaceWriter.OutputinputSurface = fname1 surfaceWriter.Execute() surfaceWriter = vmtkscripts.vmtkSurfaceWriter() surfaceWriter.Format = 'vtkxml' surfaceWriter.Surface = branchClipper.Centerlines surfaceWriter.Mode = 'ascii' surfaceWriter.OutputinputSurface = fname2 surfaceWriter.Execute() for diameter in diameters: outputName = fname1.split('.') + str(diameter) + 'mm.vtp' vessel = VesselTruncation()
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 warp_surface(args): print("warp the surface ") reader = vmtkscripts.vmtkSurfaceReader() reader.InputFileName = args.surface reader.Execute() Surface = reader.Surface narrays = Surface.GetPointData().GetNumberOfArrays() has_normals = False for i in range(narrays): if ( Surface.GetPointData().GetArrayName(i) == "Normals"): has_normals = True break if(has_normals): normals = Surface print("already have") else: get_normals = vtk.vtkPolyDataNormals() get_normals.SetInputData(Surface) get_normals.SetFeatureAngle(30.0) # default get_normals.SetSplitting(True) get_normals.Update() get_normals.GetOutput().GetPointData().SetActiveVectors("Normals") normals = get_normals.GetOutput() print("normals generated") random = vtk.vtkRandomAttributeGenerator() random.SetInputData(normals) random.SetDataTypeToDouble() random.GeneratePointScalarsOn () random.SetComponentRange(-0.5, 0.5) random.Update() #n = random.GetOutput().GetPointData().GetNumberOfArrays() #for i in range(n): #print(random.GetOutput().GetPointData().GetArrayName(i)) calc = vtk.vtkArrayCalculator() calc.SetInputConnection(random.GetOutputPort()) calc.AddScalarArrayName("RandomPointScalars", 0) calc.AddVectorArrayName("Normals", 0, 1, 2) calc.SetFunction("Normals * RandomPointScalars") calc.SetResultArrayName("RandomLengthNormalVectors") calc.Update() warp = vtk.vtkWarpVector() warp.SetInputConnection(calc.GetOutputPort()) warp.SetInputArrayToProcess(0, 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "RandomLengthNormalVectors"); warp.SetScaleFactor(args.fuzz_scale) warp.Update() writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.file_out writer.Input = warp.GetOutput() writer.Execute()
def vmtksurfacewriter(polydata, filename): writer = vmtkscripts.vmtkSurfaceWriter() writer.Surface = polydata writer.OutputFileName = filename writer.Execute()
def Execute(args): print("split centerlines") reader_ctr = vmtkscripts.vmtkSurfaceReader() reader_ctr.InputFileName = args.centerlines reader_ctr.Execute() print(args.clean_ctr) if (args.clean_ctr): cleaner = vtk.vtkCleanPolyData() cleaner.PointMergingOn() cleaner.ConvertLinesToPointsOff() #cleaner.ToleranceIsOn() cleaner.SetTolerance(args.clean_tol) # assumes mm #print(cleaner.GetTolerance()) cleaner.SetInputData(reader_ctr.Surface) cleaner.Update() centerlines = cleaner.GetOutput() else: centerlines = reader_ctr.Surface centerlines.BuildLinks() centerlines.BuildCells() #if(args.clean_ctr): #for i in range(centerlines.GetNumberOfCells()): #if centerlines.GetCell(i).GetCellType() not in (vtk.VTK_POLY_LINE, vtk.VTK_LINE): #centerlines.DeleteCell(i) #centerlines.RemoveDeletedCells() cell_Ids = vtk.vtkIdList() outputLines = vtk.vtkCellArray() output = vtk.vtkPolyData() lengthArray = vtk.vtkDoubleArray() lengthArray.SetName("length") lengthArray.SetNumberOfComponents(1) pts_ids = vtk.vtkIdList() for i in range(centerlines.GetNumberOfCells()): cell = centerlines.GetCell(i) if cell.GetCellType() not in (vtk.VTK_POLY_LINE, vtk.VTK_LINE): continue n_cell_pts = cell.GetNumberOfPoints() prevPoint = centerlines.GetPoint(cell.GetPointIds().GetId(0)) length = 0.0 start_pt_idx = 0 for j in range(n_cell_pts): centerlines.GetPointCells(cell.GetPointIds().GetId(j), cell_Ids) n_pt_neighbors = cell_Ids.GetNumberOfIds() pt_id = cell.GetPointIds().GetId(j) pts_ids.InsertNextId(pt_id) point = centerlines.GetPoint(cell.GetPointIds().GetId(j)) length += vtk.vtkMath.Distance2BetweenPoints(prevPoint, point)**0.5 prevPoint = point if ((j > start_pt_idx and n_pt_neighbors > 1) or (j == n_cell_pts - 1)): #close new_polyline = addPolyLine(pts_ids) # weird issue with duplicate points if they are not removed if (length > 0.0): outputLines.InsertNextCell(new_polyline) lengthArray.InsertNextTuple([length]) start_pt_idx = j if (n_pt_neighbors > 1): pts_ids.Reset() pts_ids.InsertNextId(pt_id) length = 0.0 pts_ids.Reset() output.SetPoints(centerlines.GetPoints()) output.SetLines(outputLines) output.GetCellData().AddArray(lengthArray) for i in range(centerlines.GetPointData().GetNumberOfArrays()): output.GetPointData().AddArray(centerlines.GetPointData().GetArray(i)) writer = vmtkscripts.vmtkSurfaceWriter() writer.OutputFileName = args.out_file if (args.clean_ctr): cleaner2 = vtk.vtkCleanPolyData() cleaner2.PointMergingOn() cleaner2.ConvertLinesToPointsOn() cleaner2.SetInputData(output) cleaner2.Update() writer.Input = cleaner2.GetOutput() else: writer.Input = output writer.Execute()