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 main(hdf5_animation_file):
weights = None
with h5py.File(hdf5_animation_file, 'r') as f:
verts = f['verts'].value
tris = f['tris'].value
if 'weights' in f:
weights = f['weights'].value
pd = tvtk.PolyData(points=verts[0], polys=tris)
normals = tvtk.PolyDataNormals(input=pd, splitting=False)
actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(input=normals.output))
actor.property.set(edge_color=(0.5, 0.5, 0.5), ambient=0.0,
specular=0.15, specular_power=128., shading=True, diffuse=0.8)
fig = mlab.figure(bgcolor=(1,1,1))
fig.scene.add_actor(actor)
@mlab.animate(delay=40, ui=False)
def animation():
for i in count():
if weights is not None:
w_str = ",".join(["%0.2f"] * weights.shape[1])
print ("Frame %d Weights = " + w_str) % tuple([i] + weights[i].tolist())
frame = i % len(verts)
pd.points = verts[frame]
fig.scene.render()
yield
a = animation()
fig.scene.z_minus_view()
mlab.show()
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 cal_mesh_normals_api(verts,tris):
pd = tvtk.PolyData(points=verts, polys=tris)
n = tvtk.PolyDataNormals(input=pd,splitting=False)
n.update()
norms = n.output.point_data.normals
#already normalized
return norms
def main(hdf5_animation_file, sid='50004', pid='jiggle_on_toes'):
with h5py.File(hdf5_animation_file, 'r') as f:
verts = f[sid + '_' + pid].value.transpose([2, 0, 1])
tris = f['faces'].value
pd = tvtk.PolyData(points=verts[0], polys=tris)
normals = tvtk.PolyDataNormals(input=pd, splitting=False)
actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(input=normals.output))
actor.property.set(edge_color=(0.5, 0.5, 0.5),
ambient=0.0,
specular=0.15,
specular_power=128.,
shading=True,
diffuse=0.8)
fig = mlab.figure(bgcolor=(1, 1, 1))
fig.scene.add_actor(actor)
@mlab.animate(delay=40, ui=False)
def animation():
for i in count():
frame = i % len(verts)
pd.points = verts[frame]
fig.scene.render()
yield
a = animation()
fig.scene.z_minus_view()
mlab.show()
def meshBody(fileName, scale=(1., 1., 1.)):
"""
Return a mesh actor and the appropriate static transform.
"""
reader = FILE_READER[splitext(fileName)[1]](file_name=fileName)
output = reader.output
# if a scale is set we have to apply it
if map(float, scale) != [1., 1., 1.]:
tpdf_transform = tvtk.Transform()
tpdf_transform.identity()
tpdf_transform.scale(scale)
tpdf = tvtk.TransformPolyDataFilter(input=reader.output, transform=tpdf_transform)
tpdf.update()
output = tpdf.output
# compute mesh normal to have a better render and reverse mesh normal
# if the scale flip them
pdn = tvtk.PolyDataNormals(input=output)
pdn.update()
output = pdn.output
pdm = tvtk.PolyDataMapper(input=output)
actor = tvtk.Actor(mapper=pdm)
actor.user_transform = tvtk.Transform()
return actor, sva.PTransformd.Identity()
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 polydata_actor(polydata, compute_normals=True):
""" create a vtk actor with given polydata as input """
if compute_normals:
normals = tvtk.PolyDataNormals(splitting=False)
configure_input_data(normals, polydata)
polydata = normals
actor = tvtk.Actor(mapper=tvtk.PolyDataMapper())
configure_input(actor.mapper, polydata)
actor.mapper.lookup_table.hue_range = (0.33, 0.)
return actor
def __init__(self, verts1, verts2, tris=None, lines=None, as_points=False,
scalars=None, scalars2=None, vmin=None, vmax=None,
actor_property=dict(specular=0.1, specular_power=128., diffuse=0.5),
):
if tris is None:
if lines is None:
rep = 'points'
else:
rep = 'wireframe'
else:
rep = 'surface'
super(Morpher, self).__init__()
self._verts1, self._verts2 = verts1, verts2
self._polydata = tvtk.PolyData(points=verts1)
if rep == 'points':
self._polydata.verts = np.r_[:len(verts1)].reshape(-1,1)
if tris is not None:
self._polydata.polys = tris
if lines is not None:
self._polydata.lines = lines
n = tvtk.PolyDataNormals(splitting=False)
configure_input_data(n, self._polydata)
self._actor = tvtk.Actor(mapper=tvtk.PolyDataMapper())
configure_input(self._actor.mapper, n)
self._actor.property.representation = rep
if rep == 'points':
self._actor.property.point_size = 5
if as_points and scalars is None:
self._polydata.point_data.scalars = \
np.random.uniform(0, 255, (len(verts1), 3)).astype(np.uint8)
self._scalars12 = None
if scalars is not None:
self._polydata.point_data.scalars = scalars
# automatically determine minimum/maximum from scalars if not given by user
if vmin is None:
vmin = scalars.min()
if scalars2 is not None:
vmin = min(vmin, scalars2.min())
if vmax is None:
vmax = scalars.max()
if scalars2 is not None:
vmax = max(vmax, scalars2.max())
if scalars.ndim == 1:
self._actor.mapper.use_lookup_table_scalar_range = False
self._actor.mapper.scalar_range = (vmin, vmax)
self._actor.mapper.lookup_table.hue_range = (0.33, 0)
# when scalars of second mesh given we need to store both scalars in order
# to interpolate between them during rendering
if scalars2 is not None:
self._scalars12 = (scalars, scalars2)
else:
self._actor.property.set(**actor_property)
mlab.gcf().scene.add_actor(self._actor)
def compute_polydata_normals(polydata):
pdnormals = tvtk.PolyDataNormals(compute_cell_normals=True,
compute_point_normals=True,
splitting=False,
consistency=False,
auto_orient_normals=False)
pdnormals.set_input_data(polydata)
pdnormals.update()
pd_with_normals = pdnormals.output
normals = pd_with_normals.cell_data.normals
return normals.to_array()
def vismesh(pts,
tris,
color=None,
edge_visibility=False,
shader=None,
triangle_scalars=None,
colors=None,
nan_color=None,
**kwargs):
if 'scalars' in kwargs and np.asarray(kwargs['scalars']).ndim == 2:
colors = kwargs['scalars']
del kwargs['scalars']
# VTK does not allow bool arrays as scalars normally, so convert to float
if 'scalars' in kwargs and np.asarray(kwargs['scalars']).dtype == np.bool:
kwargs['scalars'] = kwargs['scalars'].astype(np.float)
tm = mlab.triangular_mesh(pts[:, 0],
pts[:, 1],
pts[:, 2],
tris,
color=color,
**kwargs)
if shader is not None:
tm.actor.property.load_material(shader)
tm.actor.actor.property.shading = True
diffuse = 1.0 if colors is not None else 0.8
tm.actor.actor.property.set(edge_visibility=edge_visibility,
line_width=1,
specular=0.0,
specular_power=128.,
diffuse=diffuse)
if triangle_scalars is not None:
tm.actor.mapper.input.cell_data.scalars = triangle_scalars
tm.actor.mapper.set(scalar_mode='use_cell_data',
use_lookup_table_scalar_range=False,
scalar_visibility=True)
if "vmin" in kwargs and "vmax" in kwargs:
tm.actor.mapper.scalar_range = kwargs["vmin"], kwargs["vmax"]
if colors is not None:
# this basically is a hack which doesn't quite work,
# we have to completely replace the polydata behind the hands of mayavi
tm.mlab_source.dataset.point_data.scalars = colors.astype(np.uint8)
normals = tvtk.PolyDataNormals(splitting=False)
configure_input_data(normals, tm.mlab_source.dataset)
configure_input(tm.actor.mapper, normals)
if nan_color is not None:
if len(nan_color) == 3:
nan_color = list(nan_color) + [1]
tm.module_manager.scalar_lut_manager.lut.nan_color = nan_color
tm.update_pipeline()
return tm
def mesh_as_vtk_actor(verts,
tris,
compute_normals=True,
return_polydata=True,
scalars=None):
pd = tvtk.PolyData(points=verts, polys=tris)
if scalars is not None:
pd.point_data.scalars = scalars
if compute_normals:
normals = tvtk.PolyDataNormals(input=pd, splitting=False).output
else:
normals = pd
actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(input=normals))
if return_polydata:
return actor, pd
else:
return actor
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):
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 __init__(self, Xmean, tris, components):
HasTraits.__init__(self)
self._components = components
self._max_component_index = len(components)
self._Xmean = Xmean
self.pd = tvtk.PolyData(points=Xmean, polys=tris)
self.normals = tvtk.PolyDataNormals(splitting=False)
configure_input_data(self.normals, self.pd)
mapper = tvtk.PolyDataMapper(immediate_mode_rendering=True)
self.actor = tvtk.Actor(mapper=mapper)
configure_input(self.actor.mapper, self.normals)
self.actor.mapper.lookup_table = tvtk.LookupTable(
hue_range=(0.45, 0.6),
saturation_range=(0., 0.8),
value_range=(.6, 1.),
)
self.scene.add_actor(self.actor)
self.timer = Timer(40, self.animate().next)
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 _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 vismesh(pts,
tris,
color=None,
edge_visibility=False,
shader=None,
triangle_scalars=None,
colors=None,
**kwargs):
if 'scalars' in kwargs and np.asarray(kwargs['scalars']).ndim == 2:
colors = kwargs['scalars']
del kwargs['scalars']
tm = mlab.triangular_mesh(pts[:, 0],
pts[:, 1],
pts[:, 2],
tris,
color=color,
**kwargs)
if shader is not None:
tm.actor.property.load_material(shader)
tm.actor.actor.property.shading = True
diffuse = 1.0 if colors is not None else 0.8
tm.actor.actor.property.set(edge_visibility=edge_visibility,
line_width=1,
specular=0.0,
specular_power=128.,
diffuse=diffuse)
if triangle_scalars is not None:
tm.mlab_source.dataset.cell_data.scalars = triangle_scalars
tm.actor.mapper.set(scalar_mode='use_cell_data',
use_lookup_table_scalar_range=False,
scalar_visibility=True)
if "vmin" in kwargs and "vmax" in kwargs:
tm.actor.mapper.scalar_range = kwargs["vmin"], kwargs["vmax"]
if colors is not None:
# this basically is a hack which doesn't quite work,
# we have to completely replace the polydata behind the hands of mayavi
tm.mlab_source.dataset.point_data.scalars = colors.astype(np.uint8)
tm.actor.mapper.input = tvtk.PolyDataNormals(
input=tm.mlab_source.dataset, splitting=False).output
return tm
def add_static_background(self, data2D):
self.sp2 = copy.copy(self.sp)
self.z2 = np.reshape(np.transpose(data2D), (-1, ))
self.sp2.point_data.scalars = self.z2
self.geom_filter2 = tvtk.ImageDataGeometryFilter(input=self.sp2)
self.warp2 = tvtk.WarpScalar(input=self.geom_filter2.output)
self.normals2 = tvtk.PolyDataNormals(input=self.warp2.output)
# The rest of the VTK pipeline.
self.m2 = tvtk.PolyDataMapper(
input=self.normals2.output) #,scalar_range=(self.vmin, self.vmax))
self.p = tvtk.Property(opacity=1.0,
color=(0.5, 0.5, 0.5),
representation="w")
self.a2 = tvtk.Actor(mapper=self.m2, property=self.p)
self.ren.add_actor(self.a2)
self.rwi.initialize()
self.ren.reset_camera()
def compute_normals(pts, faces):
pd = tvtk.PolyData(points=pts, polys=faces)
n = tvtk.PolyDataNormals(splitting=False)
configure_input_data(n, pd)
n.update()
return n.output.point_data.normals.to_array()
z = numpy.reshape(numpy.transpose(5.0*numpy.sin(r)/r), (-1,) )
# Now set the scalar data for the StructuredPoints object. The
# scalars of the structured points object will be a view into our
# Numeric array. Thus, if we change `z` in-place, the changes will
# automatically affect the VTK arrays.
sp.point_data.scalars = z
# Convert this to a PolyData object.
geom_filter = tvtk.ImageDataGeometryFilter(input=sp)
# Now warp this using the scalar value to generate a carpet plot.
warp = tvtk.WarpScalar(input=geom_filter.output)
# Smooth the resulting data so it looks good.
normals = tvtk.PolyDataNormals(input=warp.output)
# The rest of the VTK pipeline.
m = tvtk.PolyDataMapper(input=normals.output,
scalar_range=(min(z), max(z)))
a = tvtk.Actor(mapper=m)
ren = tvtk.Renderer(background=(0.5, 0.5, 0.5))
ren.add_actor(a)
# Get a nice view.
cam = ren.active_camera
cam.azimuth(-60)
cam.roll(90)
# Create a RenderWindow, add the renderer and set its size.
def flip_normals(stl_fname):
# reading the stl file and getting the triangle data
reader = tvtk.STLReader()
reader.file_name = stl_fname
reader.update()
ordering = []
polydata = reader.output
points = polydata.points.to_array()
x, y, z = points.T
data = polydata.polys.to_array()
data.shape = data.size // 4, 4
ordering = np.delete(data, 0, 1)
# getting normal data of the stl file
normals = tvtk.PolyDataNormals()
configure_input(normals, polydata)
normals.compute_point_normals = 0
normals.compute_cell_normals = 1
normals.update()
polydata_normals = normals.output
u, v, w = polydata_normals.cell_data.normals.to_array().T
fig = mlab.figure(bgcolor=(0, 0, 0))
# renders the given stl file
triangles = mlab.triangular_mesh(x,
y,
z,
ordering,
figure=fig,
opacity=0.6)
# coordinates of centroids of the trianlges
centroids = np.sum(points[ordering], axis=1) / 3
centroids_x, centroids_y, centroids_z = centroids.T
# renders normals at centroids
normals = mlab.quiver3d(centroids_x,
centroids_y,
centroids_z,
u,
v,
w,
figure=fig)
centroids = mlab.points3d(centroids_x,
centroids_y,
centroids_z,
color=(0.2, 0.6, 0.1),
resolution=15)
outline = mlab.outline(line_width=3)
outline.outline_mode = "cornered"
outline_size = centroids.glyph.glyph_source.glyph_source.radius * 0.3
outline.bounds = (centroids_x[0] - outline_size, centroids_x[0] +
outline_size, centroids_y[0] - outline_size,
centroids_y[0] + outline_size, centroids_z[0] -
outline_size, centroids_z[0] + outline_size)
###########################################################################
# refer to examples/mayavi/data_interaction/select_red_balls.py for
# detailed information on using the callback
glyph_normals = centroids.glyph.glyph_source.glyph_source.output.points.\
to_array()
def picker_callback(picker):
if picker.actor in centroids.actor.actors:
centroid_id = picker.point_id // glyph_normals.shape[0]
if centroid_id != -1:
x, y, z = centroids_x[centroid_id], centroids_y[centroid_id], \
centroids_z[centroid_id]
u[centroid_id], v[centroid_id], w[centroid_id] = \
-1*u[centroid_id], -1*v[centroid_id], -1*w[centroid_id]
normals.mlab_source.set(u=u, v=v, w=w)
outline.bounds = (x - outline_size, x + outline_size,
y - outline_size, y + outline_size,
z - outline_size, z + outline_size)
picker = fig.on_mouse_pick(picker_callback)
picker.tolerance = 0.01
mlab.title("Click on centroid to invert normal",
color=(1, 1, 1),
figure=fig)
def main(*anim_files):
fig = mlab.figure(bgcolor=(1, 1, 1))
all_verts = []
pds = []
actors = []
datasets = []
glyph_pds = []
glyph_actors = []
colors = cycle([(1, 1, 1), (1, 0, 0), (0, 1, 0), (0, 0, 1)])
for i, (f, color) in enumerate(zip(anim_files, colors)):
data = h5py.File(f, 'r')
verts = data['verts'].value
tris = data['tris'].value
print f
print " Vertices: ", verts.shape
print " Triangles: ", tris.shape
datasets.append(data)
# setup mesh
pd = tvtk.PolyData(points=verts[0], polys=tris)
normals = tvtk.PolyDataNormals(compute_point_normals=True,
splitting=False)
configure_input_data(normals, pd)
actor = tvtk.Actor(mapper=tvtk.PolyDataMapper())
configure_input(actor.mapper, normals)
actor.mapper.immediate_mode_rendering = True
actor.visibility = False
fig.scene.add_actor(actor)
actors.append(actor)
all_verts.append(verts)
pds.append(normals)
# setup arrows
arrow = tvtk.ArrowSource(tip_length=0.25,
shaft_radius=0.03,
shaft_resolution=32,
tip_resolution=4)
glyph_pd = tvtk.PolyData()
glyph = tvtk.Glyph3D()
scale_factor = verts.reshape(-1, 3).ptp(0).max() * 0.1
glyph.set(scale_factor=scale_factor,
scale_mode='scale_by_vector',
color_mode='color_by_scalar')
configure_input_data(glyph, glyph_pd)
configure_source_data(glyph, arrow)
glyph_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(),
visibility=False)
configure_input(glyph_actor.mapper, glyph)
fig.scene.add_actor(glyph_actor)
glyph_actors.append(glyph_actor)
glyph_pds.append(glyph_pd)
actors[0].visibility = True
glyph_actors[0].visibility = True
class Viewer(HasTraits):
animator = Instance(Animator)
visible = Enum(*range(len(pds)))
normals = Bool(True)
export_off = Button
restpose = Bool(True)
show_scalars = Bool(True)
show_bones = Bool(True)
show_actual_bone_centers = Bool(False)
def _export_off_changed(self):
fd = FileDialog(title='Export OFF',
action='save as',
wildcard='OFF Meshes|*.off')
if fd.open() == OK:
v = all_verts[self.visible][self.animator.current_frame]
save_off(fd.path, v, tris)
@on_trait_change('visible, normals, restpose, show_scalars, show_bones'
)
def _changed(self):
for a in actors + glyph_actors:
a.visibility = False
for d in pds:
d.compute_point_normals = self.normals
actors[self.visible].visibility = True
actors[self.visible].mapper.scalar_visibility = self.show_scalars
glyph_actors[self.visible].visibility = self.show_bones
#for i, visible in enumerate(self.visibilities):
# actors[i].visibility = visible
self.animator.render = True
def show_frame(self, frame):
v = all_verts[self.visible][frame]
dataset = datasets[self.visible]
if not self.restpose:
rbms_frame = dataset['rbms'][frame]
v = v * dataset.attrs['scale'] + dataset.attrs['verts_mean']
v = blend_skinning(v,
dataset['segments'].value,
rbms_frame,
method=dataset.attrs['skinning_method'])
pds[self.visible].input.points = v
if 'scalar' in dataset and self.show_scalars:
if dataset['scalar'].shape[0] == all_verts[
self.visible].shape[0]:
scalar = dataset['scalar'][frame]
else:
scalar = dataset['scalar'].value
pds[self.visible].input.point_data.scalars = scalar
else:
pds[self.visible].input.point_data.scalars = None
if 'bone_transformations' in dataset and self.show_bones:
W = dataset['bone_blendweights'].value
T = dataset['bone_transformations'].value
gpd = glyph_pds[self.visible]
if self.show_actual_bone_centers:
verts0 = dataset['verts_restpose'].value
mean_bonepoint = verts0[W.argmax(axis=1)] # - T[0,:,:,3]
#mean_bonepoint = np.array([
# np.average(verts0, weights=w, axis=0) for w in W])
#gpd.points = np.repeat(mean_bonepoint + T[frame,:,:,3], 3, 0)
#print np.tile(mean_bonepoint + T[frame,:,:,3], 3).reshape((-1, 3))
#gpd.points = np.tile(mean_bonepoint + T[frame,:,:,3], 3).reshape((-1, 3))
pts = []
for i in xrange(T.shape[1]):
#offset = V.transform(V.hom4(mean_bonepoint[i]), T[frame,i,:,:])
offset = np.dot(T[frame, i], V.hom4(mean_bonepoint[i]))
pts += [offset] * 3
gpd.points = np.array(pts)
else:
bonepoint = np.array(
[np.average(v, weights=w, axis=0) for w in W])
gpd.points = np.repeat(bonepoint, 3, 0)
gpd.point_data.vectors = \
np.array(map(np.linalg.inv, T[frame,:,:,:3])).reshape(-1, 3)
# color vertices
vert_colors = vertex_weights_to_colors(W)
pds[self.visible].input.point_data.scalars = vert_colors
bone_colors = hue_linspace_colors(W.shape[0],
sat=0.8,
light=0.7)
gpd.point_data.scalars = np.repeat(bone_colors, 3, 0)
view = View(
Group(
Group(Item('visible'),
Item('export_off'),
Item('normals'),
Item('restpose'),
Item('show_scalars'),
Item('show_bones'),
Item('show_actual_bone_centers'),
label="Viewer"),
Item('animator', style='custom', show_label=False),
))
app = Viewer()
animator = Animator(verts.shape[0], app.show_frame)
app.animator = animator
app.edit_traits()
mlab.show()
# Now set the scalar data for the StructuredPoints object. The # scalars of the structured points object will be a view into our # Numeric array. Thus, if we change `z` in-place, the changes will # automatically affect the VTK arrays. sp.point_data.scalars = z # Convert this to a PolyData object. geom_filter = tvtk.ImageDataGeometryFilter() configure_input(geom_filter, sp) # Now warp this using the scalar value to generate a carpet plot. warp = tvtk.WarpScalar() configure_input(warp, geom_filter) # Smooth the resulting data so it looks good. normals = tvtk.PolyDataNormals() configure_input(normals, warp) # The rest of the VTK pipeline. m = tvtk.PolyDataMapper(scalar_range=(min(z), max(z))) configure_input(m, normals) a = tvtk.Actor(mapper=m) ren = tvtk.Renderer(background=(0.5, 0.5, 0.5)) ren.add_actor(a) # Get a nice view. cam = ren.active_camera cam.azimuth(-60) cam.roll(90)
def initialize(self, X, Y, initial_data=None, vmin=None, vmax=None):
"""
Create objects to plot on
"""
if initial_data == None:
initial_data = zeros(shape(X))
if vmin == None:
self.vmin = -1.0
if vmax == None:
self.vmax = 1.0
else:
if vmin == None:
self.vmin = np.min(np.min(initial_data))
if vmax == None:
self.vmax = np.max(np.max(initial_data))
x_min = np.min(np.min(X))
y_min = np.min(np.min(Y))
x_max = np.max(np.max(X))
y_max = np.max(np.max(Y))
x_middle = (x_min + x_max) / 2
y_middle = (y_min + y_max) / 2
z_middle = np.mean(np.mean(initial_data))
L = x_max - x_min
diffs = np.shape(X)
x_diff = diffs[0]
y_diff = diffs[1]
z_diff = 1.0 #self.vmax-self.vmin
self.tvtk = tvtk
self.sp = tvtk.StructuredPoints(origin=(x_middle, y_middle, z_middle),
dimensions=(x_diff, y_diff, 1),
spacing=(2 * L / (x_diff - 1),
2 * L / (y_diff - 1), 100.0))
self.z = np.transpose(initial_data).flatten()
self.sp.point_data.scalars = self.z
self.geom_filter = tvtk.ImageDataGeometryFilter(input=self.sp)
self.warp = tvtk.WarpScalar(input=self.geom_filter.output)
self.normals = tvtk.PolyDataNormals(input=self.warp.output)
# The rest of the VTK pipeline.
self.m = tvtk.PolyDataMapper(input=self.normals.output,
scalar_range=(self.vmin, self.vmax))
p = tvtk.Property(opacity=0.5, color=(1, 1, 1), representation="s")
self.a = tvtk.Actor(mapper=self.m, property=p)
self.ren = tvtk.Renderer(background=(0.0, 0.0, 0.0))
self.ren.add_actor(self.a)
# Get a nice view.
self.cam = self.ren.active_camera
self.cam.azimuth(-50)
self.cam.roll(90)
# Create a RenderWindow, add the renderer and set its size.
self.rw = tvtk.RenderWindow(size=(800, 800))
self.rw.add_renderer(self.ren)
# Create the RenderWindowInteractor
self.rwi = tvtk.RenderWindowInteractor(render_window=self.rw)
self.rwi.initialize()
self.ren.reset_camera()
self.rwi.render()
def test_help_trait(self):
"""Test if the help attribute is correct."""
n = tvtk.PolyDataNormals()
t = n.traits()
test = t['splitting'].help != t['non_manifold_traversal'].help
self.assertEqual(test, True)
def make_surf_actor(x,
y,
z,
warp=1,
scale=[1.0, 1.0, 1.0],
make_actor=True,
*args,
**kwargs):
"""Creates a surface given regularly spaced values of x, y and the
corresponding z as arrays. Also works if z is a function.
Currently works only for regular data - can be enhanced later.
Parameters
----------
x -- Array of x points (regularly spaced)
y -- Array if y points (regularly spaced)
z -- A 2D array for the x and y points with x varying fastest
and y next. Also will work if z is a callable which supports
x and y arrays as the arguments.
warp -- If true, warp the data to show a 3D surface
(default = 1).
scale -- Scale the x, y and z axis as per passed values.
Defaults to [1.0, 1.0, 1.0].
make_actor -- also create actors suitably (default True)
args -- additional positional arguments for func()
(default is empty)
kwargs -- a dict of additional keyword arguments for func()
(default is empty)
"""
if callable(z):
zval = numpy.ravel(sampler(x, y, z, *args, **kwargs))
x, y = squeeze(x), squeeze(y)
else:
x, y = squeeze(x), squeeze(y)
_check_sanity(x, y, z)
zval = numpy.ravel(z)
assert len(zval) > 0, "z is empty - nothing to plot!"
xs = x * scale[0]
ys = y * scale[1]
data = _create_structured_points_direct(xs, ys, zval)
if not make_actor:
return data
if warp:
geom_f = tvtk.ImageDataGeometryFilter()
configure_input_data(geom_f, data)
warper = tvtk.WarpScalar(scale_factor=scale[2])
configure_input_data(warper, geom_f.output)
normals = tvtk.PolyDataNormals(feature_angle=45)
configure_input_data(normals, warper.output)
mapper = tvtk.PolyDataMapper(scalar_range=(min(zval), max(zval)))
configure_input_data(mapper, normals.output)
else:
mapper = tvtk.PolyDataMapper(scalar_range=(min(zval), max(zval)))
configure_input_data(mapper, data)
actor = _make_actor(mapper=mapper)
return data, actor
def compute_normals(pd):
n = tvtk.PolyDataNormals(input=pd, splitting=False)
n.update()
return n.output.point_data.normals
