def _pipeline_default(self):
sqrt2 = numpy.sqrt(2)
x = -sqrt2 * numpy.cos(numpy.pi * 2. / 3)
y = sqrt2 * numpy.sin(numpy.pi * 2. / 3)
p1 = tvtk.PlaneSource(origin=(0,0,0), \
point1=(-sqrt2,0,1), point2=(x,y,1))
p2 = tvtk.PlaneSource(origin=(0,0,0), \
point1=(x,y,1), point2=(x,-y,1))
p3 = tvtk.PlaneSource(origin=(0,0,0), \
point1=(x,-y,1), point2=(-sqrt2,0,1))
for p in (p1, p2, p3):
p.set_resolution(32, 32)
append = tvtk.AppendPolyData()
append.add_input_connection(p1.output_port)
append.add_input_connection(p2.output_port)
append.add_input_connection(p3.output_port)
scale_f = tvtk.TransformFilter(input_connection=append.output_port,
transform=self.scale)
trans = tvtk.Transform()
trans.rotate_x(90.0)
self.imp_cyl.transform = trans
clip = tvtk.ClipPolyData(input_connection=scale_f.output_port,
clip_function=self.imp_cyl,
inside_out=True)
transF2 = tvtk.TransformFilter(input_connection=clip.output_port,
transform=self.transform)
self.config_pipeline()
return transF2
def make_tube(height, radius, resolution, rx=0, ry=0, rz=0):
cs1 = tvtk.CylinderSource(height=height,
radius=radius[0],
resolution=resolution)
cs2 = tvtk.CylinderSource(height=height + 0.1,
radius=radius[1],
resolution=resolution)
triangle1 = tvtk.TriangleFilter(input_connection=cs1.output_port)
triangle2 = tvtk.TriangleFilter(input_connection=cs2.output_port)
tr = tvtk.Transform()
tr.rotate_x(rx)
tr.rotate_y(ry)
tr.rotate_z(rz)
tf1 = tvtk.TransformFilter(transform=tr,
input_connection=triangle1.output_port)
tf2 = tvtk.TransformFilter(transform=tr,
input_connection=triangle2.output_port)
bf = tvtk.BooleanOperationPolyDataFilter()
bf.operation = "difference"
bf.set_input_connection(0, tf1.output_port)
bf.set_input_connection(1, tf2.output_port)
m = tvtk.PolyDataMapper(input_connection=bf.output_port,
scalar_visibility=False)
a = tvtk.Actor(mapper=m)
return bf, a, tf1, tf2
def _pipeline_default(self):
cyl = self.vtk_cylinder
norms = tvtk.PolyDataNormals(input_connection=cyl.output_port)
transF1 = tvtk.TransformFilter(input_connection=norms.output_port,
transform=self.cyl_trans)
transF2 = tvtk.TransformFilter(input_connection=transF1.output_port,
transform=self.transform)
self.config_pipeline()
return transF2
def _pipeline_default(self):
grid = self.vtk_grid
grid.set_execute_method(self.create_grid)
grid.modified()
trans = tvtk.Transform()
trans.rotate_x(90.)
cyl = self.vtk_cylinder
cyl.transform = trans
clip1 = tvtk.ClipVolume(input=grid.structured_points_output,
clip_function=self.vtk_cylinder,
inside_out=1)
clip2 = tvtk.ClipDataSet(input=clip1.output,
clip_function=self.vtk_quadric,
inside_out=1)
topoly = tvtk.GeometryFilter(input=clip2.output)
norms = tvtk.PolyDataNormals(input=topoly.output)
transF = tvtk.TransformFilter(input=norms.output,
transform=self.transform)
self.config_pipeline()
#clip1.update()
grid.modified()
return transF
def _pipeline_default(self):
self.config_profile()
self.config_pipeline()
source = self.data_source
def execute():
xy = self._vtk_profile()
z = numpy.ones(xy.shape[0]) * self.z_height_1
points = numpy.column_stack((xy, z))
cells = [
list(range(len(z))),
]
output = source.poly_data_output
output.points = points
output.polys = cells
source.set_execute_method(execute)
print("Made PIPELINE")
extrude = self.extrude
extrude.input_connection = source.output_port
t = self.transform
transf = tvtk.TransformFilter(input_connection=extrude.output_port,
transform=t)
return transf
def _pipeline_default(self):
source = self.data_source
def execute():
xy = self.get_real_profile()
#print "extrude1:",profile[:3]
#xy = np.column_stack((profile[:][0],profile[:][1]))
#print "extrude2: ",xy[:3]
z = numpy.ones(xy.shape[0]) * self.z_height_1
points = numpy.column_stack((xy, z))
cells = [
list(range(len(z))),
]
output = source.poly_data_output
output.points = points
output.lines = cells
print("cells: ", type(output))
source.set_execute_method(execute)
self.extrude.scale_factor = self.z_height_2 - self.z_height_1 #mm, put here because it wasn;t being initialized
if self.trace_ends:
print("drew ends")
self.extrude.capping = True
extrude = self.extrude
extrude.input = source.output
print("extrude: ", extrude.input)
t = self.transform
transf = tvtk.TransformFilter(input_connection=extrude.output_port,
transform=t)
return transf
def _pipeline_default(self):
grid = self.vtk_grid
#grid.set_execute_method(self.create_grid)
grid.modified()
trans = tvtk.Transform()
trans.rotate_x(90.)
cyl = self.vtk_cylinder
cyl.transform = trans
clip1 = tvtk.ClipVolume(input_connection=grid.output_port,
clip_function=self.vtk_cylinder,
inside_out=1)
self.clip2.set(input_connection=clip1.output_port,
clip_function=self.vtk_sphere,
inside_out=1)
topoly = tvtk.GeometryFilter(input_connection=self.clip2.output_port)
norms = tvtk.PolyDataNormals(input_connection=topoly.output_port)
transF = tvtk.TransformFilter(input_connection=norms.output_port,
transform=self.transform)
self.config_pipeline()
grid.modified()
return transF
def _pipeline_default(self):
cyl = self.vtk_disk
norms = tvtk.PolyDataNormals(input_connection=cyl.output_port)
tube = tvtk.TubeFilter(input_connection=self.line.output_port)
append = tvtk.AppendPolyData()
append.add_input_connection(norms.output_port)
append.add_input_connection(tube.output_port)
transF1 = tvtk.TransformFilter(input_connection=append.output_port,
transform=self.cyl_trans)
transF2 = tvtk.TransformFilter(input_connection=transF1.output_port,
transform=self.transform)
self.config_pipeline()
return transF2
def get_actors(self, scene):
actors = []
sList = [self.f1_glyph, self.f2_glyph]
cList = [(0, 1, 0), (1, 0, 0)]
for s, c in zip(sList, cList):
s.radius = 1.0
map = tvtk.PolyDataMapper(input_connection=s.output_port)
act = tvtk.Actor(mapper=map, user_transform=self.transform)
act.property.color = c
actors.append(act)
line = tvtk.LineSource(point1=(-100, 0, 0), point2=(100, 0, 0))
t_line = tvtk.TransformFilter(
input_connection=line.output_port,
transform=self.ellipse_trans.linear_inverse)
map = tvtk.PolyDataMapper(input_connection=t_line.output_port)
act = tvtk.Actor(mapper=map, user_transform=self.transform)
act.property.color = (0, 0, 0)
actors.append(act)
l1 = tvtk.VectorText(text="F1")
l2 = tvtk.VectorText(text="F2")
m1 = tvtk.PolyDataMapper(input_connection=l1.output_port)
m2 = tvtk.PolyDataMapper(input_connection=l2.output_port)
act1 = self.f1_act
act2 = self.f2_act
act1.mapper = m1
act2.mapper = m2
scale = (5, 5, 5)
act1.scale = scale
act2.scale = scale
act1.property.color = (0, 0, 0)
act2.property.color = (0, 0, 0)
act1.position = self.focus1
act2.position = self.focus2
def on_editor(new_ed):
if new_ed is not None:
act1.camera = new_ed._camera
act2.camera = new_ed._camera
scene.on_trait_change(on_editor, "scene_editor")
actors.append(act1)
actors.append(act2)
for actor in actors:
self.actors.append(actor)
self.foci_Actors.append(actor)
actor.visibility = self.show_foci
return self.actors
def _actors_default(self):
source = self.plane_src
trans_f = tvtk.TransformFilter(input_connection=source.output_port,
transform = self.transform)
map = tvtk.PolyDataMapper(input_connection=trans_f.output_port)
act = tvtk.Actor(mapper=map)
actors = tvtk.ActorCollection()
actors.append(act)
return actors
def _pipeline_default(self):
cyl = self.cyl
cyl.resolution = 63 #use a prime no to avoid vertex degeneracy
# Important to ensure the cylinder end doesn't coincide with the corner of the cube
cyl.height = self.thickness - 1
cyl.radius = self.diameter / 2.0
cyl.center = (0, (self.thickness / 2) - 1, 0)
print("thickness", self.thickness)
print("diameter", self.diameter)
size = max(self.thickness, self.diameter) * 2
cube = self.cube
cube.set_bounds(0, size, 0, size, 0, size)
tf = tvtk.Transform()
tf.post_multiply()
tf.rotate_x(-45.0)
tf.rotate_wxyz(35.26438968275, 0, 0, 1)
tfilt = tvtk.TransformFilter(input_connection=cube.output_port)
tfilt.transform = tf
tri1 = tvtk.TriangleFilter(input_connection=cyl.output_port)
tri2 = tvtk.TriangleFilter(input_connection=tfilt.output_port)
tri1.update()
tri2.update()
intersect = tvtk.BooleanOperationPolyDataFilter()
intersect.operation = "intersection"
intersect.add_input_connection(0, tri1.output_port)
intersect.add_input_connection(1, tri2.output_port)
intersect.tolerance = 1e-8
tf2 = tvtk.Transform()
tf2.rotate_x(90.0)
tf2.rotate_y(60.0)
orient = tvtk.TransformFilter(input_connection=intersect.output_port,
transform=tf2)
norm = tvtk.PolyDataNormals(input_connection=orient.output_port)
transF = tvtk.TransformFilter(input_connection=norm.output_port,
transform=self.transform)
self.config_pipeline()
return transF
def _pipeline_default(self):
source = self.data_source
def execute():
polydata = self._polydata
output = source.poly_data_output
output.shallow_copy(polydata)
source.set_execute_method(execute)
t = self.transform
transf = tvtk.TransformFilter(input_connection=source.output_port,
transform=t)
tri = tvtk.TriangleFilter(input_connection=transf.output_port)
return tri
def _pipeline_default(self):
self.body.set_execute_method(self.calc_profile)
extrude = tvtk.LinearExtrusionFilter(input=self.body.output)
extrude.extrusion_type = "vector"
extrude.vector = (0, 1, 0)
extrude.scale_factor = self.length
# cut parabolics.py here and inserted from prisms.py
t = self.transform
transF = tvtk.TransformFilter(input=extrude.output, transform=t)
return transF
def _pipeline_default(self):
grid = self.vtk_grid
#grid.set_execute_method(self.create_grid)
grid.modified()
trans = tvtk.Transform()
trans.rotate_x(90.)
cyl = self.vtk_cylinder
cyl.transform = trans
clip1 = tvtk.ClipVolume(input_connection=grid.output_port,
clip_function=self.vtk_cylinder,
inside_out=1)
self.clip2.set(input_connection=clip1.output_port,
clip_function=self.vtk_sphere1,
inside_out=1)
self.clip3.set(input_connection=self.clip2.output_port,
clip_function=self.vtk_sphere3,
inside_out=1)
clip4 = tvtk.ClipDataSet(input_connection=self.clip3.output_port,
clip_function=self.vtk_sphere2,
inside_out=1)
clip5 = tvtk.ClipDataSet(input_connection=self.clip3.output_port,
clip_function=self.vtk_sphere2,
inside_out=0)
topoly = tvtk.GeometryFilter(input_connection=clip4.output_port)
topoly2 = tvtk.GeometryFilter(input_connection=clip5.output_port)
append = tvtk.AppendPolyData()
append.add_input_connection(topoly.output_port)
append.add_input_connection(topoly2.output_port)
norms = tvtk.PolyDataNormals(input_connection=append.output_port)
transF = tvtk.TransformFilter(input_connection=norms.output_port,
transform=self.transform)
self.on_geometry_changed()
self.config_pipeline()
grid.modified()
return transF
def _pipeline_default(self):
#pretty much just copied this from extruded_interpolant, and added three profile points
source = self.data_source
def execute():
opening = .5 * self.entry_width
d = self.depth
slant = self.slant
x1 = opening
y1 = 0
x2 = opening - (d / np.tan(np.radians(slant)))
y2 = -d
profile = self.get_real_profile()
profile[0] = np.append(profile[0], [x2, -x2], 1)
profile[1] = np.append(profile[1], [y2, y2], 1)
xy = np.column_stack((profile[:][0], profile[:][1]))
z = np.ones(xy.shape[0]) * self.z_height_1
points = np.column_stack((xy, z))
cells = [
list(range(len(z))),
]
output = source.poly_data_output
output.points = points
output.polys = cells
source.set_execute_method(execute)
self.extrude.scale_factor = self.z_height_2 - self.z_height_1 #mm, put here because it wasn;t being initialized
if self.trace_ends:
print("drew ends")
self.extrude.capping = True
extrude = self.extrude
extrude.input = source.output
t = self.transform
transf = tvtk.TransformFilter(input_connection=extrude.output_port,
transform=t)
return transf
def _pipeline_default(self):
grid = self.vtk_grid
#grid.set_execute_method(self.create_grid)
grid.modified()
quad = self.vtk_quadric
quad.transform = self.ellipse_trans
clip = tvtk.ClipVolume(input_connection=grid.output_port,
clip_function=quad,
inside_out=0)
topoly = tvtk.GeometryFilter(input_connection=clip.output_port)
norm = tvtk.PolyDataNormals(input_connection=topoly.output_port)
transF = tvtk.TransformFilter(input_connection=norm.output_port,
transform=self.transform)
self.config_pipeline()
grid.modified()
return transF
def __init__(self):
self.el = 0.0
self.az = 0.0
# Create an arrow.
arrow = tvtk.ArrowSource()
# Transform it suitably so it is oriented correctly.
t = tvtk.Transform()
tf = tvtk.TransformFilter()
tf.transform = t
t.rotate_y(90.0)
t.translate((-2, 0, 0))
configure_input_data(tf, arrow.output)
mapper = tvtk.PolyDataMapper()
configure_input(mapper, tf)
self.actor = actor = tvtk.Follower()
actor.mapper = mapper
prop = actor.property
prop.color = 0, 1, 1
prop.ambient = 0.5
prop.diffuse = 0.5
def setup_pipeline(self):
self._transform = tvtk.Transform()
self.widget = tvtk.BoxWidget(place_factor=1.1)
self.filter = tvtk.TransformFilter()
super(TransformData, self).setup_pipeline()
def _pipeline_default(self):
transf = tvtk.TransformFilter(input=self.vtk_disk.output,
transform=self.transform)
return transf
