## Set options. # # u: logitudinal direction: # v: circumferential direction: # # KnotSpanTypes: average, derivative, equal # # ParametricSpanType: centripetal, chord, equal # # Linear degree 1, quadratic degree 2, cubic degree 3, and quintic degree 5. # options = sv.geometry.LoftNurbsOptions() ## Loft surface. # loft_surf = sv.geometry.loft_nurbs(polydata_list=contour_list, loft_options=options) gr.add_geometry(renderer, loft_surf, color=[0.5, 0.0, 0.0], wire=True) ## Show geometry. # camera = renderer.GetActiveCamera() camera.Zoom(0.5) #camera.SetPosition(center[0], center[1], center[2]) cont1 = contours[10] center = cont1.get_center() camera.SetFocalPoint(center[0], center[1], center[2]) gr.display(renderer_window)
return surfacefilter.GetOutput() if __name__ == '__main__': file_name = sys.argv[1] # Read centerlines. reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(file_name) reader.Update() centerlines = reader.GetOutput() ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) gr_geom = gr.add_geometry(renderer, centerlines, color=[1.0, 1.0, 1.0], line_width=1) num_centerlines = get_centerline_info(centerlines) min_id = 0 max_id = num_centerlines-1 # Create a color lookup table. lut = vtk.vtkLookupTable() lut.SetTableRange(min_id, max_id+1) lut.SetHueRange(0, 1) lut.SetSaturationRange(1, 1) lut.SetValueRange(1, 1) lut.Build() extract_data(renderer, lut, centerlines)
modeler = sv.modeling.Modeler(kernel) ## Create a cylinder. print("Create a cylinder.") center = [0.0, 0.0, 0.0] axis = [0.0, 0.0, 1.0] radius = 1.5 length = 10.0 cyl = modeler.cylinder(center, axis, radius, length) face_ids = cyl.get_face_ids() print("Model face IDs: " + str(face_ids)) ## Write the model. cyl.write(file_name=str(script_path / "cylinder-parasolid")) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. polydata = cyl.get_polydata() gr.add_geometry(renderer, polydata, color=[1.0, 0.0, 0.0], wire=False, edges=True) # Display window. gr.display(renderer_window)
print(" Box type: " + str(type(box))) box_pd = box.get_polydata() print(" Box: num nodes: {0:d}".format(box_pd.GetNumberOfPoints())) # oc_box = oc_modeler.box(center, width=width, length=length, height=height) print(" OC Box type: " + str(type(oc_box))) oc_box_pd = oc_box.get_polydata() print(" OC Box: num nodes: {0:d}".format(oc_box_pd.GetNumberOfPoints())) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. gr.add_geometry(renderer, box_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) gr.add_geometry(renderer, oc_box_pd, color=[1.0, 0.0, 0.0], wire=True, edges=False) ## Add a sphere. gr.add_sphere(renderer, center=center, radius=0.1, color=[1.0, 1.0, 1.0], wire=True) pt1 = center pt2 = [ center[0]+width/2.0, center[1], center[2] ] gr.add_line(renderer, pt1, pt2, color=[0.5, 0.0, 0.0], width=4) pt1 = center pt2 = [ center[0], center[1]+height/2, center[2] ] gr.add_line(renderer, pt1, pt2, color=[0.0, 0.5, 0.0], width=4) pt1 = center pt2 = [ center[0], center[1], center[2]+length/2.0 ]
#loft_options.interpolate_spline_points = False options.interpolate_spline_points = True # Set the number of points to sample a spline if # using linear interpolation between sample points. options.num_spline_points = 50 # The number of longitudinal points used to sample splines. options.num_long_points = 200 ## Loft solid. # print("Loft solid ...") loft_surf = sv.geometry.loft(polydata_list=contour_list, loft_options=options) #gr.add_geometry(renderer, loft_surf, color=[0.8, 0.8, 0.8], wire=True) gr.add_geometry(renderer, loft_surf, color=[0.8, 0.8, 0.8], wire=False) ## Write the lofted surface. # if options.interpolate_spline_points: file_name = str(script_path / 'loft-test-interpolate.vtp') else: file_name = str(script_path / 'loft-test.vtp') writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(file_name) writer.SetInputData(loft_surf) writer.Update() writer.Write() ## Show geometry.
## Write the capped surface. # print("Write the capped surface.") file_name = str(script_path / "cylinder-surface-capped.vtp") writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(file_name) writer.SetInputData(capped_cylinder) writer.Update() writer.Write() ## Create a model from the capped surface. print("Create a model from the capped surface.") capped_model = sv.modeling.PolyData() capped_model.set_surface(surface=capped_cylinder) face_ids = capped_model.compute_boundary_faces(angle=60.0) print("Model face IDs: " + str(face_ids)) capped_model.write("cylinder-surface-capped-model", "vtp") # Add geometry to vtk renderer. #gr.add_geom(renderer, cylinder_polydata, color=[0.5, 0.0, 0.0], wire=True) gr.add_geometry(renderer, capped_cylinder, color=[0.0, 1.0, 0.0], wire=True) ## Show geometry. # camera = renderer.GetActiveCamera() #camera.Zoom(0.5) #camera.SetPosition(center[0], center[1], center[2]) camera.SetFocalPoint(center[0], center[1], center[2]) gr.display(renderer_window)
mesh_file = script_path / 'cylinder-mehs.vtu' mesher.write_mesh(file_name=str(mesh_file)) ## Show the mesh. # if 'gr' in dir(): ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) #mesh_polydata = gr.convert_ug_to_polydata(mesh) mesh_surface = mesher.get_surface() gr.add_geometry(renderer, mesh_surface, color=[1.0, 1.0, 1.0], wire=True, edges=True) #gr.add_geometry(renderer, mesh_polydata, color=[1.0, 1.0, 1.0], wire=False, edges=True) #mesh_model_polydata = mesher.get_model_polydata() #gr.add_geometry(renderer, mesh_model_polydata, color=[0.0, 1.0, 1.0], wire=True, edges=True) face1_polydata = mesher.get_face_polydata(1) gr.add_geometry(renderer, face1_polydata, color=[1.0, 0.0, 0.0], wire=False, edges=True) face2_polydata = mesher.get_face_polydata(2)
def add_cap(self, inlet=True): print("========== add caps ==========") print("[add_caps] Inlet: {0:d}".format(inlet)) print("[add_caps] Number of inner edge components: {0:d}".format( len(self.inner_surface_edges_comp))) print("[add_caps] Number of outer edge components: {0:d}".format( len(self.outer_surface_edges_comp))) inner_contour, outer_contour = self.get_edge_component(inlet) inner_points = inner_contour.GetPoints() num_inner_points = inner_points.GetNumberOfPoints() #print("[add_caps] Number of inner points: {0:d}".format(num_inner_points)) outer_points = outer_contour.GetPoints() num_outer_points = outer_points.GetNumberOfPoints() #print("[add_caps] Number of outer points: {0:d}".format(num_outer_points)) gr.add_geometry(self.renderer, inner_contour, [0.0, 1.0, 0.0], wire=False) gr.add_geometry(self.renderer, outer_contour, [1.0, 0.0, 0.0], wire=False) cap_polydata = vtk.vtkPolyData() cap_points = vtk.vtkPoints() cap_cells = vtk.vtkCellArray() tri = vtk.vtkTriangle() ## Add points. # pt = 3 * [0.0] for i in range(num_inner_points): pt = inner_points.GetPoint(i) cap_points.InsertNextPoint(pt[0], pt[1], pt[2]) for i in range(num_inner_points): pt = outer_points.GetPoint(i) cap_points.InsertNextPoint(pt[0], pt[1], pt[2]) r = 0.02 gr.add_sphere(renderer, inner_points.GetPoint(0), r, color=[1.0, 0.0, 0.0], wire=False) gr.add_sphere(renderer, inner_points.GetPoint(1), r, color=[0.0, 1.0, 0.0], wire=False) gr.add_sphere(renderer, inner_points.GetPoint(2), r, color=[0.0, 0.0, 1.0], wire=False) gr.add_sphere(renderer, inner_points.GetPoint(3), r, color=[1.0, 1.0, 0.0], wire=False) gr.add_sphere(renderer, inner_points.GetPoint(4), r, color=[1.0, 0.0, 1.0], wire=False) gr.add_sphere(renderer, outer_points.GetPoint(0), r, color=[1.0, 0.0, 0.0], wire=False) gr.add_sphere(renderer, outer_points.GetPoint(1), r, color=[0.0, 1.0, 0.0], wire=False) gr.add_sphere(renderer, outer_points.GetPoint(2), r, color=[0.0, 0.0, 1.0], wire=False) gr.add_sphere(renderer, outer_points.GetPoint(3), r, color=[1.0, 1.0, 0.0], wire=False) gr.add_sphere(renderer, outer_points.GetPoint(4), r, color=[1.0, 0.0, 1.0], wire=False) ## Add triangles. # n = num_inner_points #for i in range(0,2): for i in range(num_inner_points): j = (i + 1) % num_inner_points #print("i {0:d} j {1:d}".format(i,j)) tri = vtk.vtkTriangle() tri.GetPointIds().SetId(0, i) tri.GetPointIds().SetId(1, i + n) tri.GetPointIds().SetId(2, j + n) cap_cells.InsertNextCell(tri) tri = vtk.vtkTriangle() tri.GetPointIds().SetId(0, i) tri.GetPointIds().SetId(1, j + n) tri.GetPointIds().SetId(2, j) cap_cells.InsertNextCell(tri) cap_polydata.SetPoints(cap_points) cap_polydata.SetPolys(cap_cells) gr.add_geometry(self.renderer, cap_polydata, [1.0, 1.0, 1.0], wire=False) return cap_polydata
def show_outer_surface(self, color, wire=False, edges=False): gr.add_geometry(self.renderer, self.outer_surface, color, edges, wire)
## Build models for the right iliac. model_name = 'right_iliac' seg_file_name = "../../../data/DemoProject/Segmentations/" + model_name + ".ctgr" iliac_vessel_model = VesselModel(renderer, sv.modeling.Kernel.POLYDATA) iliac_vessel_model.create_solid_models(model_name, seg_file_name) #iliac_vessel_model.show_inner_model(color=[1.0,0.0,0.0], wire=False, edges=False) #iliac_vessel_model.show_outer_model(color=[0.0,1.0,0.0], wire=False, edges=False) iliac_vessel_model.show_segmentations(color=[1.0, 1.0, 1.0]) ## Union vessels. modeler = sv.modeling.Modeler(sv.modeling.Kernel.POLYDATA) inner_union = modeler.union(aorta_vessel_model.inner_model, iliac_vessel_model.inner_model) #gr.add_geometry(renderer, inner_union.get_polydata(), color=[1.0,0.0,1.0]) outer_union = modeler.union(aorta_vessel_model.outer_model, iliac_vessel_model.outer_model) #gr.add_geometry(renderer, outer_union.get_polydata(), color=[1.0,0.0,1.0]) ## Subtract union vessels to get vessel wall. vessel_wall = modeler.subtract(main=outer_union, subtract=inner_union) #face_ids = vessel_wall.compute_boundary_faces(angle=50.0) face_ids = vessel_wall.get_face_ids() print("Vessel wall model face IDs: " + str(face_ids)) gr.add_geometry(renderer, vessel_wall.get_polydata(), color=[1.0, 0.0, 1.0]) vessel_wall.write(file_name="vessel-wall", format="vtp") ## Display window. gr.display(renderer_window)
def show_outer_model(self, color, wire=False, edges=False): polydata = self.outer_model.get_polydata() gr.add_geometry(self.renderer, polydata, color, edges, wire)
cont1 = contours[10] center = cont1.get_center() cont1_polydata = cont1.get_polydata() gr.create_contour_geometry(renderer, cont1) # Create interpolated geometry for the contour. cont1_ipd = sv.geometry.interpolate_closed_curve(cont1_polydata, num_samples) # Get two points on interpolated curve. pt = 3 * [0.0] cont1_ipd.GetPoints().GetPoint(0, pt) gr.add_sphere(renderer, pt, radius, color=[1, 0, 0]) cont1_ipd.GetPoints().GetPoint(4, pt) gr.add_sphere(renderer, pt, radius, color=[0, 1, 0]) gr.add_geometry(renderer, cont1_ipd) ## cont2 # cont2 = contours[11] points2 = cont2.get_points() cont2_polydata = cont2.get_polydata() gr.create_contour_geometry(renderer, cont2) cont2_ipd = sv.geometry.interpolate_closed_curve(cont2_polydata, num_samples) ## Align contours. use_dist = False use_dist = True cont2_align_pd = sv.geometry.align_profile(cont1_ipd, cont2_ipd, use_dist) # Get two points on aligned curve.
except: print("Can't find the new-api-tests/graphics package.") ## Initialize graphics. # win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Read model to smooth. file_name = str(data_path / 'geometry' / 'two-cyls.vtp') reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(file_name) reader.Update() model = reader.GetOutput() gr.add_geometry(renderer, model, wire=True) radius = 1.0 center = [-0.1, 4.0, -0.4] gr.add_sphere(renderer, center, radius, color=[0,1,0], wire=True) ## Perform the smoothing operation. smoothing_params = { 'method':'laplacian', 'num_iterations':100, 'relaxation_factor':0.01 } smoothing_params = { 'method':'constrained', 'num_iterations':5, 'constrain_factor':0.2, 'num_cg_solves':30 } smoothed_model = sv.geometry.local_sphere_smooth(model, radius, center, smoothing_params) gr.add_geometry(renderer, smoothed_model, color=[1,0,0]) ## Show geometry. gr.display(renderer_window)
#normals_pd.BuildLinks() print(" normals_pd: num nodes: {0:d}".format(normals_pd.GetNumberOfPoints())) writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName("box.vtp") writer.SetInputData(normals_pd) #writer.SetInputData(box_pd) writer.Update() writer.Write() writer = vtk.vtkPolyDataWriter() writer.SetFileName("box.vtk") writer.SetInputData(normals_pd) writer.Update() writer.Write() # ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. gr.add_geometry(renderer, normals_pd, color=[0.0, 1.0, 0.0]) #gr.add_geometry(renderer, box_pd, color=[0.0, 1.0, 0.0]) #gr.add_geometry(renderer, box_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) # Display window. gr.display(renderer_window)
(1, [0.0,1.0,0.0]), (2, [1.0,0.0,0.0]) ] for i, entry in enumerate(num_subdivision_operations_list): num_subdivision_operations = entry[0] color = entry[1] print("Blend num_subdivision_operations : {0:g}".format( num_subdivision_operations)) options.num_subdivision_operations = num_subdivision_operations blend = sv.geometry.local_blend(surface=model, faces=blend_faces, options=options) print(" Blend: Num nodes: {0:d}".format(blend.GetNumberOfPoints())) print(" Blend: Num cells: {0:d}".format(blend.GetNumberOfCells())) if i == 2: gr.add_geometry(renderer, blend, color=color, wire=True) else: gr.add_geometry(renderer, blend, color=color, wire=False) ## Write the blended surface. file_name = str(script_path / str("blend-numsubbdiv-" + str(i) + ".vtp")) writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(file_name) writer.SetInputData(blend) writer.Update() writer.Write() ## Show geometry. gr.display(renderer_window)
def show_outer_aligned_contours(self, color): for contour in self.outer_aligned_contours: gr.add_geometry(renderer, contour, color)
sys.path.insert(1, '../graphics/') import graphics as gr # Create a modeler. #modeler = sv.modeling.Modeler(sv.modeling.Kernel.OPENCASCADE) modeler = sv.modeling.Modeler(sv.modeling.Kernel.POLYDATA) ## Create a sphere. print("Create a sphere ...") center = [0.0, 0.0, 0.0] radius = 2.0 sphere = modeler.sphere(center=center, radius=radius) print(" Sphere type: " + str(type(sphere))) sphere_pd = sphere.get_polydata() print(" Sphere: num nodes: {0:d}".format(sphere_pd.GetNumberOfPoints())) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. gr.add_geometry(renderer, sphere_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) # Display window. gr.display(renderer_window)
def show_edges(self, color): gr.add_geometry(renderer, self.inner_surface_edges, color) gr.add_geometry(renderer, self.outer_surface_edges, color)
sys.path.insert(1, '../../../graphics/') import graphics as gr ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) modeler = sv.modeling.Modeler(sv.modeling.Kernel.POLYDATA) inner_model = modeler.read('inner-union.vtp') face_ids = inner_model.compute_boundary_faces(angle=50.0) outer_model = modeler.read('outer-union.vtp') face_ids = outer_model.compute_boundary_faces(angle=50.0) print("Outer Model face IDs: " + str(face_ids)) ## Perform a Boolean subtract. vessel_wall = modeler.subtract(main=outer_model, subtract=inner_model) face_ids = vessel_wall.compute_boundary_faces(angle=50.0) face_ids = vessel_wall.get_face_ids() print("Vessel wall model face IDs: " + str(face_ids)) vessel_wall_pd = vessel_wall.get_polydata() file_format = "vtp" vessel_wall.write(file_name="vessel-wall", format=file_format) gr.add_geometry(renderer, vessel_wall_pd, color=[1.0, 1.0, 1.0], wire=True) ## Display window. gr.display(renderer_window)
## Compute boundary faces if needed. # try: face_ids = model.get_face_ids() except: face_ids = model.compute_boundary_faces(angle=60.0) print("Model face IDs: " + str(face_ids)) ## Write the model. if False: file_name = str(script_Path / "model-written") file_format = "vtp" model.write(file_name=file_name, format=file_format) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. model_pd = model.get_polydata() gr.add_geometry(renderer, model_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) face1_polydata = model.get_face_polydata(face_id=face_ids[0]) gr.add_geometry(renderer, face1_polydata, color=[1.0, 0.0, 0.0], wire=False) # Display window. gr.display(renderer_window)
''' Test TetGen interface. ''' import sv import sys import vtk sys.path.insert(1, '../graphics/') import graphics as gr from mesh_utils import setup_mesher ## Create a mesher and load a model. mesher = setup_mesher(sv.meshing.Kernel.TETGEN) ## Get the model polydata. # mesh_model_polydata = mesher.get_model_polydata() ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) gr.add_geometry(renderer, mesh_model_polydata, color=[0.0, 1.0, 1.0], wire=True, edges=True) gr.display(renderer_window)
show_region(renderer, surface, regions[w], color=[0,1,0]) if region_count == 3: show_region(renderer, surface, regions[w], color=[0,0,1]) if region_count == 4: show_region(renderer, surface, regions[w], color=[0.5,0.51,0.51]) region_count += 1 if __name__ == '__main__': file_name = sys.argv[1] file_prefix, file_extension = os.path.splitext(file_name) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Read in surface. surface = Surface() surface.read(file_name) model_polydata = surface.geometry gr_geom = gr.add_geometry(renderer, model_polydata, color=[0.8, 0.8, 8.0]) print("Num nodes: {0:d}".format(model_polydata.GetNumberOfPoints())) print("Num cells: {0:d}".format(model_polydata.GetNumberOfCells())) compute_faces(renderer, model_polydata) ## Display window. gr.display(renderer_window)
box_pd = box.get_polydata() print(" Box: num nodes: {0:d}".format(box_pd.GetNumberOfPoints())) ## Create a cylinder. print("Create a cylinder ...") center = [0.0, 0.0, 1.0] axis = [0.0, 0.0, 1.0] radius = 1.5 length = 10.0 cylinder = modeler.cylinder(center, axis, radius, length) cylinder_pd = cylinder.get_polydata() ## Subtract the cylinder from the box. print("Union the cylinder and the box ...") result = modeler.union(model1=box, model2=cylinder) result_pd = result.get_polydata() ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. #gr.add_geometry(renderer, box_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) #gr.add_geometry(renderer, cylinder_pd, color=[0.0, 0.0, 1.0], wire=True, edges=False) gr.add_geometry(renderer, result_pd, color=[1.0, 0.0, 0.0], wire=True, edges=False) # Display window. gr.display(renderer_window)
#mesher.write_mesh(file_name='aorta-iliac-mesh.vtu') ## Show the mesh. # show_mesh = True if show_mesh: win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) #mesh_polydata = gr.convert_ug_to_polydata(mesh) mesh_surface = mesher.get_surface() #gr.add_geometry(renderer, mesh_surface, color=[1.0, 1.0, 1.0], wire=True, edges=True) gr.add_geometry(renderer, mesh_surface, color=[1.0, 1.0, 1.0], wire=False, edges=True) #mesh_model_polydata = mesher.get_model_polydata() #gr.add_geometry(renderer, mesh_model_polydata, color=[0.0, 1.0, 1.0], wire=True, edges=True) #face1_polydata = mesher.get_face_polydata(1) #gr.add_geometry(renderer, face1_polydata, color=[1.0, 0.0, 0.0], wire=False, edges=True) #face2_polydata = mesher.get_face_polydata(2) #gr.add_geometry(renderer, face2_polydata, color=[0.0, 1.0, 0.0], wire=False, edges=True) #face3_polydata = mesher.get_face_polydata(3) #gr.add_geometry(renderer, face3_polydata, color=[0.0, 0.0, 1.0], wire=False, edges=True)
# oc_ellipsoid = oc_modeler.ellipsoid(center=center, radii=radii) print(" OC Ellipsoid type: " + str(type(oc_ellipsoid))) oc_ellipsoid_pd = oc_ellipsoid.get_polydata() print(" OC Ellipsoid: num nodes: {0:d}".format( oc_ellipsoid_pd.GetNumberOfPoints())) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. gr.add_geometry(renderer, ellipsoid_pd, color=[0.0, 1.0, 0.0], wire=True, edges=False) #gr.add_geometry(renderer, oc_ellipsoid_pd, color=[1.0, 0.0, 0.0], wire=True, edges=False) ## Add a sphere. gr.add_sphere(renderer, center=center, radius=0.1, color=[1.0, 1.0, 1.0], wire=True) pt1 = center pt2 = [center[i] + length / 2.0 * axis[i] for i in range(3)] gr.add_line(renderer, pt1, pt2, color=[0.5, 0.0, 0.0], width=4)
#end_cid = 4 use_distance = True num_profile_points = 25 tolerance = 1e-3 for cid in range(start_cid,end_cid): cont_ipd = get_profile_contour(gr, renderer, contours, cid, num_profile_points) if cid == start_cid: cont_align = cont_ipd else: cont_align = sv.geometry.align_profile(last_cont_align, cont_ipd, use_distance) curve = modeler.interpolate_curve(cont_align) #curve = modeler.approximate_curve(cont_align, tolerance) curve_pd = curve.get_polydata() gr.add_geometry(renderer, curve_pd, color=[1.0, 0.0, 0.0]) curve_list.append(curve) #add_sphere(gr, renderer, cont_align, radius) last_cont_align = cont_align ## Create a lofted surface. # print("Create lofted surface ...") loft_surf = modeler.loft(curve_list=curve_list) gr.add_geometry(renderer, loft_surf.get_polydata(), color=[0.8, 0.8, 0.8], wire=False) ## Show geometry. # camera = renderer.GetActiveCamera(); camera.Zoom(0.5)
def extract_data(renderer, lut, centerlines): print("---------- extract_data ----------") data_array = centerlines.GetPointData().GetArray('CenterlineId') num_centerlines = get_centerline_info(centerlines) min_id = 0 max_id = num_centerlines-1 cid_list = list(range(min_id,max_id+1)) max_radius_data = centerlines.GetPointData().GetArray('MaximumInscribedSphereRadius') num_lines = centerlines.GetNumberOfLines() num_points = centerlines.GetNumberOfPoints() points = centerlines.GetPoints() print("Number of centerline lines: {0:d}".format(num_lines)) #pt = points.GetPoint(0) #gr.add_sphere(renderer, pt, 0.5, color=[1,1,1], wire=True) max_num_lines = 0 longest_cid = None for cid in range(min_id,max_id+1): section = extract_centerline(centerlines, cid) if section.GetNumberOfLines() > max_num_lines: max_num_lines = section.GetNumberOfLines() longest_cid = cid print("Longest cid: {0:d} number of lines: {1:d}".format(longest_cid, max_num_lines)) cell_cids = defaultdict(list) for cid in cid_list: #print("\n---------- cid {0:d} ----------".format(cid)) for i in range(num_lines): cell = centerlines.GetCell(i) cell_pids = cell.GetPointIds() num_ids = cell_pids.GetNumberOfIds() pid1 = cell_pids.GetId(0) pid2 = cell_pids.GetId(1) value1 = int(data_array.GetComponent(pid1, cid)) value2 = int(data_array.GetComponent(pid2, cid)) if (value1 == 1) or (value2 == 1): cell_cids[i].append(cid) #_for j in range(num_ids) #_for i in range(num_lines) #_for cid in range(min_id,max_id+1) cell_mask = vtk.vtkIntArray() cell_mask.SetNumberOfValues(num_lines) cell_mask.SetName("CellMask") centerlines.GetCellData().AddArray(cell_mask) branch_cells = defaultdict(list) radius = 0.4 radius = 0.1 #cid_list.remove(longest_cid) for cid in cid_list: #print("\n---------- find start cid {0:d} ----------".format(cid)) for i in range(num_lines): cids = cell_cids[i] if longest_cid in cids: #if (longest_cid in cids) and (i not in branch_cells[longest_cid]): if i not in branch_cells[longest_cid]: branch_cells[longest_cid].append(i) else: if (len(cids) == 1) and (cids[0] == cid): branch_cells[cid].append(i) if cid in cell_cids[i]: cell_cids[i].remove(cid) #_for j in range(num_ids) #show_branch(renderer, lut, centerlines, cid, branch_cells, radius) #_for cid in cid_list end_point_ids = get_end_points(renderer, lut, centerlines) #for cid in [0]: #for cid in [longest_cid]: for cid in cid_list: color = [0.0, 0.0, 0.0] lut.GetColor(cid, color) branch_geom = create_branch(renderer, lut, centerlines, cid, branch_cells, radius, end_point_ids) if cid == longest_cid: gr.add_geometry(renderer, branch_geom, color=[1,1,1], line_width=4) else: gr.add_geometry(renderer, branch_geom, color=color, line_width=2) '''
center = compute_junction_center(renderer, bnd_model) gr.add_sphere(renderer, center, blend_radius, color=[0.0, 1.0, 0.0], wire=True) ## Read model to blend. file_name = str(data_path / 'geometry' / 'two-cyls.vtp') reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(file_name) reader.Update() model = reader.GetOutput() ## Set faces to blend. if "two-cyls.vtp" in file_name: blend_faces = [{'radius': blend_radius, 'face1': 1, 'face2': 2}] ## Perform the blend operation. blend = sv.geometry.local_blend(surface=model, faces=blend_faces, options=options) gr.add_geometry(renderer, blend, wire=True) ## Write the blended surface. file_name = str(script_path / str("blended-" + file_name)) writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(file_name) writer.SetInputData(blend) writer.Update() writer.Write() ## Show geometry. gr.display(renderer_window)
writer.SetInputData(loft_capped) writer.Update() writer.Write() ## Remesh suface. # modeler = sv.modeling.Modeler(sv.modeling.Kernel.POLYDATA) model = sv.modeling.PolyData() model.set_surface(surface=loft_capped) model.compute_boundary_faces(angle=60.0) remesh_model = sv.mesh_utils.remesh(model.get_polydata(), hmin=0.2, hmax=0.2) model.set_surface(surface=remesh_model) model.compute_boundary_faces(angle=60.0) model.write("loft-nurb-test", format="vtp") polydata = model.get_polydata() gr.add_geometry(renderer, polydata, color=[1.0, 1.0, 1.0], edges=True) print("Model: ") print(" Number of points: " + str(polydata.GetNumberOfPoints())) print(" Number of cells: " + str(polydata.GetNumberOfCells())) ## Show geometry. # camera = renderer.GetActiveCamera() camera.Zoom(0.5) #camera.SetPosition(center[0], center[1], center[2]) cont1 = contours[10] center = cont1.get_center() camera.SetFocalPoint(center[0], center[1], center[2]) gr.display(renderer_window)
file_name = "cylinder.stl" file_name = "loft-test-interpolate.vtp" model = modeler.read(file_name) print("Model type: " + str(type(model))) ## Compute boundary faces. face_ids = model.compute_boundary_faces(angle=60.0) print("Model face IDs: " + str(face_ids)) ## Write the model. if False: file_name = "model-written" file_format = "vtp" model.write(file_name=file_name, format=file_format) ## Create renderer and graphics window. win_width = 500 win_height = 500 renderer, renderer_window = gr.init_graphics(win_width, win_height) ## Add model polydata. model_pd = model.get_polydata() gr.add_geometry(renderer, model_pd, color=[0.0, 1.0, 0.0], wire=False, edges=False) # Display window. gr.display(renderer_window)