## 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)
