from enthought.tvtk.api import tvtk from math import * from numpy import * from geometry import *
zDirection = array((0, 0, 1))
class Pipe:
def __init__(self):
self.points = []
self.pipeRibs = {}
def addRib(self, spokeLengths):
count = len(self.pipeRibs)
self.pipeRibs[count] = PipeRib(self, spokeLengths)
def spokeEndPoint(self, ribIndex, spokeIndex):
pipeRib = self.pipeRibs[ribIndex]
angleStep = 2 * pi / len(pipeRib.spokeLengths)
angle = angleStep * spokeIndex
length = pipeRib.spokeLengths[spokeIndex]
position = length * array((cos(angle), sin(angle)))
return array((position[0], position[1], 0))
def ribOriginPoint(self, ribIndex):
p1 = array(pipe.points[ribIndex])
p2 = array(pipe.points[ribIndex+1])
return centerPoint(p1, p2)
def makeSpokeActor(self, ribIndex, spokeIndex):
spoke = tvtk.LineSource(point1=array((0, 0, 0)),
point2=self.spokeEndPoint(ribIndex, spokeIndex))
spokeTransformFilter = tvtk.TransformFilter(input=spoke.output)
spokeTransform = tvtk.Transform()
spokeTransform.translate(self.ribOriginPoint(ribIndex))
#spokeTransform.rotate_wxyz(degrees(rotationAngle), axis[0], axis[1], axis[2])
spokeTransform.concatenate(self.boneRotationTransform(ribIndex))
spokeTransformFilter.transform = spokeTransform
spokeMapper = tvtk.PolyDataMapper(input=spokeTransformFilter.output)
spokeActor = tvtk.Actor(mapper=spokeMapper)
return spokeActor
def boneDirection(self, ribIndex):
p1 = array(pipe.points[ribIndex])
p2 = array(pipe.points[ribIndex+1])
return unitVectorFromPoints(p1, p2)
def boneRotationTransform(self, ribIndex):
transform = tvtk.Transform()
rotationAngle = acos(vdot(zDirection, self.boneDirection(ribIndex)))
axis = cross(zDirection, self.boneDirection(ribIndex))
transform.rotate_wxyz(degrees(rotationAngle), axis[0], axis[1], axis[2])
return transform
def endOfSpokePoint(self, ribIndex, spokeIndex):
transform = tvtk.Transform()
#spokeEndPoint = array((position[0], position[1], 0))
spokeEndPoint = pipe.spokeEndPoint(ribIndex, spokeIndex)
#print "rotationAngle", rotationAngle, "axis", axis
transform.translate(self.ribOriginPoint(ribIndex))
#transform.rotate_wxyz(degrees(rotationAngle), axis[0], axis[1], axis[2])
transform.concatenate(self.boneRotationTransform(ribIndex))
transform.translate(spokeEndPoint)
return transform.position
def makeEndOfSpokeMarkerActor(self, ribIndex, spokeIndex):
# create end of spoke marker
transform = tvtk.Transform()
sphere = tvtk.SphereSource(theta_resolution=12, phi_resolution=12)
transform.translate(self.endOfSpokePoint(ribIndex, spokeIndex))
transform.scale((0.2, 0.2, 0.2))
transformFilter = tvtk.TransformFilter(input=sphere.output)
transformFilter.transform = transform
mapper = tvtk.PolyDataMapper(input=transformFilter.output)
actor = tvtk.Actor(mapper=mapper)
return actor
class PipeRib:
def __init__(self, parentPipe, spokeLengths):
self.parentPipe = parentPipe
self.spokeLengths = spokeLengths
pipe = Pipe()
pipe.points.append((0, 0, 0))
pipe.points.append((0, 0, 4))
pipe.points.append((1, 1, 8))
pipe.points.append((1, 0, 14))
pipe.addRib([2, 2, 2])
pipe.addRib([2, 2, 3])
pipe.addRib([2, 2, 2])
if 0:
#sphereSource = tvtk.SphereSource(theta_resolution=12, phi_resolution=12) cs1 = tvtk.ConeSource(resolution=100) transform1 = tvtk.Transform() transform1.rotate_y(20) transform1.translate((5, 0, 0)) cs2 = tvtk.ConeSource(resolution=100) transform2 = tvtk.Transform() tf1 = tvtk.TransformFilter(input=cs1.output) tf2 = tvtk.TransformFilter(input=cs1.output) tf1.transform = transform1 tf2.transform = transform2 mapper1 = tvtk.PolyDataMapper(input=tf1.output) mapper2 = tvtk.PolyDataMapper(input=tf2.output)
if 0:
cs = tvtk.ConeSource(resolution=100) mapper = tvtk.PolyDataMapper(input=cs.output) actor = tvtk.Actor(mapper=mapper) #actor1 = tvtk.Actor(mapper=mapper1) #actor2 = tvtk.Actor(mapper=mapper2)
- create a renderer:
renderer = tvtk.Renderer()
- create a render window and hand it the renderer:
render_window = tvtk.RenderWindow(size=(400,400)) render_window.add_renderer(renderer)
- create interactor and hand it the render window
- This handles mouse interaction with window.
interactor = tvtk.RenderWindowInteractor(render_window=render_window)
- renderer.add_actor(actor)
- renderer.add_actor(actor1)
- renderer.add_actor(actor2)
print "rendering"
def renderPipe():
for i in range(len(pipe.points)):
point = pipe.points[i]
sphere = tvtk.SphereSource(theta_resolution=12, phi_resolution=12)
transform = tvtk.Transform()
transform.translate(point)
transformFilter = tvtk.TransformFilter(input=sphere.output)
transformFilter.transform = transform
mapper = tvtk.PolyDataMapper(input=transformFilter.output)
actor = tvtk.Actor(mapper=mapper)
renderer.add_actor(actor)
if i < (len(pipe.points) - 1):
pipeRib = pipe.pipeRibs[i]
p1 = array(pipe.points[i])
p2 = array(pipe.points[i+1])
bone = tvtk.LineSource(point1=p1, point2=p2)
mapper = tvtk.PolyDataMapper(input=bone.output)
actor = tvtk.Actor(mapper=mapper)
renderer.add_actor(actor)
#angleStep = 2 * pi / len(pipeRib.spokeLengths)
#boneCenter = centerPoint(p1, p2)
boneCenter = pipe.ribOriginPoint(i)
for spokeIndex in range(len(pipeRib.spokeLengths)):
#angle = angleStep * spokeIndex
#length = pipeRib.spokeLengths[spokeIndex]
#position = length * array((cos(angle), sin(angle)))
endOfSpokeMarkerActor = pipe.makeEndOfSpokeMarkerActor(i, spokeIndex)
renderer.add_actor(endOfSpokeMarkerActor)
spokeActor = pipe.makeSpokeActor(i, spokeIndex)
renderer.add_actor(spokeActor)
if i < (len(pipe.points) - 2):
for spokeIndex in range(len(pipeRib.spokeLengths)):
if spokeIndex == len(pipeRib.spokeLengths) - 1:
nextSpokeIndex = 0
else:
nextSpokeIndex = spokeIndex + 1
print "i", i, "(len(pipe.points) - 1)", (len(pipe.points) - 1)
point1 = pipe.endOfSpokePoint(i, spokeIndex)
point2 = pipe.endOfSpokePoint(i, nextSpokeIndex)
point3 = pipe.endOfSpokePoint(i+1, nextSpokeIndex)
point4 = pipe.endOfSpokePoint(i+1, spokeIndex)
point1 = [point1[0], point1[1], point1[2]]
#point2 = [0, 1, 0]
#point3 = [1, 1, 0]
#point4 = [1, 0, 0]
points = array([point1, point2, point3, point4], 'f')
quads = array(0, 1, 2, 3)
#print points
#points = array([[0,0,0], [0,1,0], [1,1,0], [1,0,0], [0,0,1], [0,1,1]], 'f')
#quads = array([[0,1,2,3], [0,4,5,1]])
#points, temperature = data[:,:3], data[:,-1]
mesh = tvtk.PolyData(points=points, polys=quads)
#mesh.point_data.scalars = temperature
#triangleFilter = tvtk.TriangleFilter(input=mesh)
#butterflyFilter = tvtk.ButterflySubdivisionFilter(input=triangleFilter.output,
# number_of_subdivisions=5)
#mapper = tvtk.PolyDataMapper(input=butterflyFilter.output)
triangleFilter = tvtk.TriangleFilter(input=mesh)
butterflyFilter = tvtk.ButterflySubdivisionFilter(input=triangleFilter.output,
number_of_subdivisions=5)
#butterflyFilter = tvtk.ButterflySubdivisionFilter(input=mesh,
# number_of_subdivisions=5)
#mapper = tvtk.PolyDataMapper(input=mesh)
mapper = tvtk.PolyDataMapper(input=butterflyFilter.output)
actor = tvtk.Actor(mapper=mapper)
renderer.add_actor(actor)
renderPipe()
interactor.initialize()
interactor.start()