def __init__(self):
self.renderer, self.render_window = sv_vis.initRen('ContourTest')
"""
This script tests the vmtk_utils module.
"""
import sv
import sv_vis as vis
import os
import sys
## Create a render and window to display geometry.
renderer, render_window = vis.initRen('demo')
surf_name = "shapeSnakeDiaSmooth"
surf_file_name = surf_name + ".vtp"
## Create a solid model from polydata.
#
sv.solid.set_kernel('PolyData')
solid = sv.solid.SolidModel()
# Read surface polydata.
solid.read_native(surf_name, surf_file_name)
## Display surface.
surf_pd = surf_name + "_pd"
solid.get_polydata(surf_pd, 1.0)
vis.pRepos(renderer, surf_pd)
vis.polyDisplayWireframe(renderer, surf_pd)
## Cap the surface.
capped_surf_name = surf_name + "_capped"
surf_pd += 'b'
import sv
import sv_vis as vis
print(dir(sv))
ren, renwin = vis.initRen('Test Path')
#------------------------------------------
# Create a path
#------------------------------------------
path_name = "path1"
path_control_points = []
path_control_points.append([2.0, 2.0, 0.0])
path_control_points.append([3.0, 3.0, 0.0])
path_control_points.append([4.0, 4.0, 0.0])
path_control_points.append([5.0, 5.0, 0.0])
path = sv.path.Path()
path.new_object(path_name)
## Set path points.
for i in range(0, len(path_control_points)):
path.add_control_point(path_control_points[i])
## Create path geometry?
path.create()
points = path.get_curve_points()
control_points = path.get_control_points()
# Get path PolyData
path_pd_name = path_name + 'pd'
# Creat contour.
c.Create()
print(">>> Contour center: " + str(c.Center()))
# Get countour PolyData
pname = name + 'p'
c.GetPolyData(pname)
#c.GetPolyData('ctp')
act = vis.pRepos(ren, pname)
#vis.polyDisplayWireframe(ren, name)
#__create_contours(path)
ren, renwin = vis.initRen('demo')
## Create a path.
control_points1 = []
control_points1.append([2.0, 2.0, 0.0])
control_points1.append([3.0, 3.0, 0.0])
control_points1.append([4.0, 4.0, 0.0])
control_points1.append([5.0, 5.0, 0.0])
radius1 = 1.0
create_contours('path1', control_points1, radius1, ren)
control_points2 = []
control_points2.append([0.0, 0.0, 0.0])
control_points2.append([0.0, 1.0, 0.0])
control_points2.append([0.0, 2.0, 0.0])
control_points2.append([0.0, 3.0, 0.0])
# Create new path object. path2_name = 'path2' path2 = Path.pyPath() path2.NewObject(path2_name) # Give it some points. path2.AddPoint([0.0, 100.0, 0.0]) path2.AddPoint([0.0, 100.0, 10.0]) path2.AddPoint([0.0, 100.0, 20.0]) path2.AddPoint([1.0, 100.0, 30.0]) path2.AddPoint([0.0, 100.0, 40.0]) path2.AddPoint([0.0, 100.0, 50.0]) path2.AddPoint([0.0, 100.0, 60.0]) # Generate the path from the added control points. path2.CreatePath() # Create solids from the paths. path1_solid_name = create_solid_from_path(path1_name, 5.0) path2_solid_name = create_solid_from_path(path2_name, 5.0) # Render this all to a viewer. window_name = 'contour_to_lofted_model.py' ren, renwin = vis.initRen(window_name) actor1 = vis.pRepos(ren, path1_solid_name) actor2 = vis.pRepos(ren, path2_solid_name) # Set the renderer to draw the solids as a wireframe. vis.polyDisplayWireframe(ren, path1_solid_name) vis.polyDisplayWireframe(ren, path2_solid_name) vis.interact(ren, 15000)
sv.solid.set_kernel('PolyData')
solid = sv.solid.SolidModel()
solid.read_native(model_name, solid_file_name)
solid.get_boundary_faces(60)
print("Model face IDs: " + str(solid.get_face_ids()))
model_polydata_name = model_name + "_pd"
solid.get_polydata(model_polydata_name)
model_actor = sv_vis.pRepos(renderer, model_polydata_name)[1]
model_actor.GetProperty().SetColor(0.8, 0.8, 0.8)
#sv_vis.polyDisplayWireframe(renderer, model_polydata)
sv_vis.polyDisplayPoints(renderer, model_polydata_name)
return solid, model_polydata_name, solid_file_name
## Create a render and window to display geometry.
renderer, render_window = sv_vis.initRen('mesh-mess')
## Read solid model.
#
# Assume the first id in 'face_ids' is the source, the rest
# are targets for the centerline calculation.
#
model_name = "aorta-outer"
model_name = "aorta-small"
if model_name == "aorta-outer":
edge_size = 0.4733
face_ids = [2, 3]
#
elif model_name == "demo":
face_ids = [2, 3, 4]
print("\n[geom_stats_demo] Geom.Clean()")
cleaned_name = merged_solid_name_pd + "_cleaned"
Geom.Clean(merged_solid_name_pd, cleaned_name)
# Sometimes errors out with: "current kernel is not valid (6)" ?
print("\n[geom_stats_demo] Geom.All_union()")
inter_t = True
destination_name = merged_solid_name_pd + "_merged_again"
result = Geom.All_union([path1_surface_name, path2_surface_name], inter_t,
destination_name)
print("\n[geom_stats_demo] Geom.Intersect()")
intersected_solid_name = "intersected_solid"
Geom.Intersect(merged_solid_name_pd, cube_name_pd, intersected_solid_name)
window_name = "INTERSECTED Model"
ren1, renwin1 = vis.initRen(window_name)
actor1 = vis.pRepos(ren1, intersected_solid_name)
# Set the renderer to draw the solids as a wireframe.
vis.polyDisplayWireframe(ren1, intersected_solid_name)
print("\n[geom_stats_demo] Geom.Subtract()")
subtracted_solid_name = "subtracted_solid"
Geom.Subtract(merged_solid_name_pd, cube_name_pd, subtracted_solid_name)
window_name = "SUBTRACTED Model"
ren2, renwin2 = vis.initRen(window_name)
actor2 = vis.pRepos(ren2, subtracted_solid_name)
# Set the renderer to draw the solids as a wireframe.
vis.polyDisplayWireframe(ren2, subtracted_solid_name)
vis.interact(ren1, 15000)
vis.interact(ren2, 15000)
import sv
import sv_vis as vis
print(dir(sv))
ren, renwin = vis.initRen('Test Contour')
#------------------------------------------
# Create a path
#------------------------------------------
path_name = "path1"
path_control_points = []
path_control_points.append([2.0, 2.0, 0.0])
path_control_points.append([3.0, 3.0, 0.0])
path_control_points.append([4.0, 4.0, 0.0])
path_control_points.append([5.0, 5.0, 0.0])
path = sv.path.Path()
path.new_object(path_name)
## Set path points.
for i in range(0,len(path_control_points)):
path.add_control_point(path_control_points[i])
## Create path geometry?
path.create()
points = path.get_curve_points()
control_points = path.get_control_points()
# Get path PolyData
path_pd_name = path_name + 'pd'
2) Generate a finite element mesh from the model
3) Generate the mesh and .svpre files needed to run a simulation using svsolver.
'''
import os
from shutil import copyfile
import sv
import sv_vis as vis
import sys
import vtk
## Create a render and window to display geometry.
renderer, render_window = vis.initRen('model-to-sim')
use_graphics = False
#-------------------------------------------------------------#
# M o d e l i n g #
#-------------------------------------------------------------#
print("---------- Modeling ----------")
solid_name = 'demo'
solid_name = 'cylinder'
if solid_name == 'cylinder':
# Faces:
# face 1: surface
# face 2: inlet
# face 3: outlet
solid_file_name = 'cylinder.vtp'
