def draw_cubic_solid(origin,size):
actors = []
x = numpy.array([1,0,0])
y = numpy.array([0,1,0])
z = numpy.array([0,0,1])
verts = [ origin + y*size,
origin + y*size + x*size,
origin + y*size + x*size + z*size,
origin + y*size + z*size,
origin,
origin + x*size,
origin + x*size + z*size,
origin + z*size]
# indexes into verts
edges = [ [0,1], [1,2], [2,3], [3,0],
[4,5], [5,6], [6,7], [7,4],
[4,0], [5,1], [6,2], [7,3] ]
pd = tvtk.PolyData()
pd.points = verts
pd.lines = edges
if 1:
pt = tvtk.TubeFilter(radius=0.0254*0.5,input=pd,
number_of_sides=12,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
actors.append(a)
return actors
def setup_pipeline(self):
"""Override this method so that it *creates* the tvtk
pipeline.
This method is invoked when the object is initialized via
`__init__`. Note that at the time this method is called, the
tvtk data pipeline will *not* yet be setup. So upstream data
will not be available. The idea is that you simply create the
basic objects and setup those parts of the pipeline not
dependent on upstream sources and filters. You should also
set the `actors` attribute up at this point.
"""
# Create and setup the default objects.
self.seed = SourceWidget()
self.stream_tracer = tvtk.StreamTracer(
maximum_propagation=50,
integration_direction='forward',
compute_vorticity=True,
integrator_type='runge_kutta4',
)
self.ribbon_filter = tvtk.RibbonFilter()
self.tube_filter = tvtk.TubeFilter()
self.clean_filter = tvtk.CleanPolyData()
self.actor = Actor()
# Setup the actor suitably for this module.
self.actor.property.line_width = 2.0
def cylindrical_post(info=None):
verts = info['verts']
diameter = info['diameter']
radius = diameter / 2.0
actors = []
verts = numpy.asarray(verts)
pd = tvtk.PolyData()
np = len(verts) - 1
lines = numpy.zeros((np, 2), numpy.int64)
lines[:, 0] = numpy.arange(0, np - 0.5, 1, numpy.int64)
lines[:, 1] = numpy.arange(1, np + 0.5, 1, numpy.int64)
pd.points = verts
pd.lines = lines
pt = tvtk.TubeFilter(
radius=radius,
input=pd,
number_of_sides=20,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = 0, 0, 0
a.property.specular = 0.3
actors.append(a)
return actors
def axes_actor(origin=(0, 0, 0), scale_factor=1.0, radius=0.02, sides=12):
"""Creates a simple axes actor and returns a tvtk.Actor object."""
axes = tvtk.Axes(origin=origin, scale_factor=scale_factor, symmetric=1)
tube = tvtk.TubeFilter(radius=radius,
number_of_sides=sides,
vary_radius='vary_radius_off',
input=axes.output)
mapper = tvtk.PolyDataMapper(input=tube.output)
actor = tvtk.Actor(mapper=mapper)
return actor
def make_2_vert_tube(a, b):
pd = tvtk.PolyData(points=[a, b], lines=[[0, 1]])
pt = tvtk.TubeFilter(
radius=tube_radius, number_of_sides=20, vary_radius="vary_radius_off",
)
configure_input_data(pt, pd)
m = tvtk.PolyDataMapper(input_connection=pt.output_port)
a = tvtk.Actor(mapper=m)
a.property.color = 0, 0, 0
a.property.specular = 0.3
return a
def make_2_vert_tube(a, b):
pd = tvtk.PolyData()
pd.points = [a, b]
pd.lines = [[0, 1]]
pt = tvtk.TubeFilter(
radius=tube_radius,
input=pd,
number_of_sides=20,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = 0, 0, 0
a.property.specular = 0.3
return a
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_tvtk_actors(self):
filename = self.filename
kwargs = self.kwargs
actors = []
# mamarama
z = 0
N = 64
radius = 1.0
center = numpy.array([1.0, 0, 0])
verts = []
vi = 0 # vert idx
lines = []
theta = numpy.linspace(0, 2 * math.pi, N, endpoint=False)
X = radius * numpy.cos(theta) + center[0]
Y = radius * numpy.sin(theta) + center[1]
height = 0.762
for z in numpy.linspace(0, height, 4):
Z = numpy.zeros(theta.shape) + center[2] + z
v = numpy.array([X, Y, Z]).T
for i in range(N):
verts.append(v[i])
for i in range(N - 1):
lines.append([i + vi, i + 1 + vi])
lines.append([vi + N - 1, vi])
vi += N
pd = tvtk.PolyData()
pd.points = verts
pd.lines = lines
pt = tvtk.TubeFilter(
radius=0.001,
input=pd,
number_of_sides=4,
vary_radius="vary_radius_off",
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = 0.9, 0.9, 0.9
a.property.specular = 0.3
actors.append(a)
return actors
def get_tvtk_actors(self):
actors = []
verts,lines = self._get_verts_lines()
pd = tvtk.PolyData()
pd.points = verts
pd.lines = lines
pt = tvtk.TubeFilter(radius=0.001,input=pd,
number_of_sides=4,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
actors.append(a)
return actors
def sphere_arena(info=None):
N = 32
theta = numpy.linspace(0, 2 * numpy.pi, N)
r = info['radius']
xs = r * numpy.cos(theta) + info['origin'][0]
ys = r * numpy.sin(theta) + info['origin'][1]
els = numpy.linspace(-np.pi / 2, np.pi / 2, 10)
# z_levels = numpy.linspace(info['origin'][2]-info['radius'],
# info['origin'][2]+info['radius'],
# 5)
verts = []
vi = 0 # vert idx
lines = []
for el in els:
zs = np.sin(el) * numpy.ones_like(
xs) * info['radius'] + info['origin'][2]
R = np.cos(el)
v = numpy.array([R * xs, R * ys, zs]).T
for i in range(N):
verts.append(v[i])
for i in range(N - 1):
lines.append([i + vi, i + 1 + vi])
lines.append([vi + N - 1, vi])
vi += (N)
pd = tvtk.PolyData()
pd.points = verts
pd.lines = lines
pt = tvtk.TubeFilter(
radius=0.001,
input=pd,
number_of_sides=4,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
return [a]
def cylindrical_arena(info=None):
assert numpy.allclose(info['axis'], numpy.array(
[0, 0, 1])), ("only vertical areas supported at the moment")
N = 128
theta = numpy.linspace(0, 2 * numpy.pi, N)
r = info['diameter'] / 2.0
xs = r * numpy.cos(theta) + info['origin'][0]
ys = r * numpy.sin(theta) + info['origin'][1]
z_levels = numpy.linspace(info['origin'][2],
info['origin'][2] + info['height'], 5)
verts = []
vi = 0 # vert idx
lines = []
for z in z_levels:
zs = z * numpy.ones_like(xs)
v = numpy.array([xs, ys, zs]).T
for i in range(N):
verts.append(v[i])
for i in range(N - 1):
lines.append([i + vi, i + 1 + vi])
lines.append([vi + N - 1, vi])
vi += (N)
pd = tvtk.PolyData(points=verts, lines=lines)
pt = tvtk.TubeFilter(
radius=0.001,
number_of_sides=4,
vary_radius='vary_radius_off',
)
configure_input_data(pt, pd)
m = tvtk.PolyDataMapper(input_connection=pt.output_port)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
return [a]
def simple_tvtk(verts,polys):
actors = []
pd = tvtk.PolyData()
verts = numpy.array(verts)
if verts.shape[1]==4:
onetest = verts[:,3]
assert numpy.allclose(1,onetest)
verts = verts[:,:3]
pd.points = verts
pd.lines = polys
if 1:
pt = tvtk.TubeFilter(radius=0.001,input=pd,
number_of_sides=12,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
actors.append(a)
return actors
sphere = tvtk.SphereSource(center=(2, center[1], center[2]),
radius=2,
phi_resolution=6,
theta_resolution=6)
sphere_mapper = tvtk.PolyDataMapper(input_connection=sphere.output_port)
sphere_actor = tvtk.Actor(mapper=sphere_mapper)
sphere_actor.property.set(representation="wireframe", color=(0, 0, 0))
streamer = tvtk.StreamLine(step_length=0.0001,
integration_direction="forward",
integrator=tvtk.RungeKutta4())
streamer.set_input_data(grid)
streamer.set_source_connection(sphere.output_port)
tube = tvtk.TubeFilter(input_connection=streamer.output_port,
radius=0.05,
number_of_sides=6,
vary_radius="vary_radius_by_scalar")
tube_mapper = tvtk.PolyDataMapper(input_connection=tube.output_port,
scalar_range=grid.point_data.scalars.range)
tube_actor = tvtk.Actor(mapper=tube_mapper)
tube_actor.property.backface_culling = True
outline_actor = make_outline(grid)
win = ivtk_scene([outline_actor, sphere_actor, tube_actor, arrows_actor])
win.scene.isometric_view()
event_loop()
def vtk_actors(self):
if (self.actors is None):
self.actors = []
points = _getfem_to_tvtk_points(self.sl.pts())
(triangles, cv2tr) = self.sl.splxs(2)
triangles = numpy.array(triangles.transpose(), 'I')
data = tvtk.PolyData(points=points, polys=triangles)
if self.scalar_data is not None:
data.point_data.scalars = numpy.array(self.scalar_data)
if self.vector_data is not None:
data.point_data.vectors = numpy.array(self.vector_data)
if self.glyph_name is not None:
mask = tvtk.MaskPoints()
mask.maximum_number_of_points = self.glyph_nb_pts
mask.random_mode = True
mask.input = data
if self.glyph_name == 'default':
if self.vector_data is not None:
self.glyph_name = 'arrow'
else:
self.glyph_name = 'ball'
glyph = tvtk.Glyph3D()
glyph.scale_mode = 'scale_by_vector'
glyph.color_mode = 'color_by_scalar'
#glyph.scale_mode = 'data_scaling_off'
glyph.vector_mode = 'use_vector' # or 'use_normal'
glyph.input = mask.output
if self.glyph_name == 'arrow':
glyph.source = tvtk.ArrowSource().output
elif self.glyph_name == 'ball':
glyph.source = tvtk.SphereSource().output
elif self.glyph_name == 'cone':
glyph.source = tvtk.ConeSource().output
elif self.glyph_name == 'cylinder':
glyph.source = tvtk.CylinderSource().output
elif self.glyph_name == 'cube':
glyph.source = tvtk.CubeSource().output
else:
raise Exception("Unknown glyph name..")
#glyph.scaling = 1
#glyph.scale_factor = self.glyph_scale_factor
data = glyph.output
if self.show_faces:
## if self.deform is not None:
## data.point_data.vectors = array(numarray.transpose(self.deform))
## warper = tvtk.WarpVector(input=data)
## data = warper.output
## lut = tvtk.LookupTable()
## lut.hue_range = 0.667,0
## c=gf_colormap('tripod')
## lut.number_of_table_values=c.shape[0]
## for i in range(0,c.shape[0]):
## lut.set_table_value(i,c[i,0],c[i,1],c[i,2],1)
self.mapper = tvtk.PolyDataMapper(input=data)
self.mapper.scalar_range = self.scalar_data_range
self.mapper.scalar_visibility = True
# Create mesh actor for display
self.actors += [tvtk.Actor(mapper=self.mapper)]
if self.show_edges:
(Pe, E1, E2) = self.sl.edges()
if Pe.size:
E = numpy.array(
numpy.concatenate((E1.transpose(), E2.transpose()),
axis=0), 'I')
edges = tvtk.PolyData(points=_getfem_to_tvtk_points(Pe),
polys=E)
mapper_edges = tvtk.PolyDataMapper(input=edges)
actor_edges = tvtk.Actor(mapper=mapper_edges)
actor_edges.property.representation = 'wireframe'
#actor_edges.property.configure_traits()
actor_edges.property.color = self.edges_color
actor_edges.property.line_width = self.edges_width
actor_edges.property.ambient = 0.5
self.actors += [actor_edges]
if self.sl.nbsplxs(1):
# plot tubes
(seg, cv2seg) = self.sl.splxs(1)
seg = numpy.array(seg.transpose(), 'I')
data = tvtk.Axes(origin=(0, 0, 0),
scale_factor=0.5,
symmetric=1)
data = tvtk.PolyData(points=points, lines=seg)
tube = tvtk.TubeFilter(radius=0.4,
number_of_sides=10,
vary_radius='vary_radius_off',
input=data)
mapper = tvtk.PolyDataMapper(input=tube.output)
actor_tubes = tvtk.Actor(mapper=mapper)
#actor_tubes.property.representation = 'wireframe'
actor_tubes.property.color = self.tube_color
#actor_tubes.property.line_width = 8
#actor_tubes.property.ambient = 0.5
self.actors += [actor_tubes]
if self.use_scalar_bar:
self.scalar_bar = tvtk.ScalarBarActor(
title=self.scalar_data_name,
orientation='horizontal',
width=0.8,
height=0.07)
self.scalar_bar.position_coordinate.coordinate_system = 'normalized_viewport'
self.scalar_bar.position_coordinate.value = 0.1, 0.01, 0.0
self.actors += [self.scalar_bar]
if (self.lookup_table is not None):
self.set_colormap(self.lookup_table)
return self.actors
def get_tvtk_actors(self):
filename = self.filename
kwargs = self.kwargs
### draw floor
actors = []
x0 = -1.5/2
x1 = 1.5/2
y0 = -.305/2
y1 = .305/2
z0 = .314
inc = 0.05
if 1:
nx = int(math.ceil((x1-x0)/inc))
ny = int(math.ceil((y1-y0)/inc))
eps = 1e-10
x1 = x0+nx*inc+eps
y1 = y0+ny*inc+eps
segs = []
for x in numpy.r_[x0:x1:inc]:
seg =[(x,y0,z0),
(x,y1,z0)]
segs.append(seg)
for y in numpy.r_[y0:y1:inc]:
seg =[(x0,y,z0),
(x1,y,z0)]
segs.append(seg)
if 1:
verts = []
for seg in segs:
verts.extend(seg)
verts = numpy.asarray(verts)
pd = tvtk.PolyData()
np = len(verts)/2
lines = numpy.zeros((np, 2), numpy.int64)
lines[:,0] = 2*numpy.arange(np,dtype=numpy.int64)
lines[:,1] = lines[:,0]+1
pd.points = verts
pd.lines = lines
pt = tvtk.TubeFilter(radius=0.001,input=pd,
number_of_sides=4,
vary_radius='vary_radius_off',
)
m = tvtk.PolyDataMapper(input=pt.output)
a = tvtk.Actor(mapper=m)
a.property.color = .9, .9, .9
a.property.specular = 0.3
actors.append(a)
###################
stim = None
try:
condition, stim = conditions.get_condition_stimname_from_filename(filename, **kwargs)
print 'Data from condition "%s",with stimulus'%(condition,),stim
except KeyError, err:
if kwargs.get('force_stimulus',False):
raise
else:
print 'Unknown condition and stimname'
