def _glyph_type_changed(self, value): if self.glyph_type == 'vector': self.glyph = tvtk.Glyph3D(clamping=True) else: self.glyph = tvtk.TensorGlyph(scale_factor=0.1) self.show_scale_mode = False self.glyph.on_trait_change(self.render)
def convexhull(ch3d): poly = tvtk.PolyData() poly.points = ch3d.points poly.polys = ch3d.simplices sphere = tvtk.SphereSource(radius=0.02) points3d = tvtk.Glyph3D() points3d.set_source_connection(sphere.output_port) points3d.set_input_data(poly) # 绘制凸多面体的面,设置半透明度 m1 = tvtk.PolyDataMapper() m1.set_input_data(poly) a1 = tvtk.Actor(mapper=m1) a1.property.opacity = 0.3 # 绘制凸多面体的边,设置为红色 m2 = tvtk.PolyDataMapper() m2.set_input_data(poly) a2 = tvtk.Actor(mapper=m2) a2.property.representation = "wireframe" a2.property.line_width = 2.0 a2.property.color = (1.0, 0, 0) # 绘制凸多面体的顶点,设置为绿色 m3 = tvtk.PolyDataMapper(input_connection=points3d.output_port) a3 = tvtk.Actor(mapper=m3) a3.property.color = (0.0, 1.0, 0.0) return [a1, a2, a3]
def vtk_convexhull(ch, radius=0.02): from tvtk.api import tvtk poly = tvtk.PolyData() poly.points = ch.points poly.polys = ch.simplices sphere = tvtk.SphereSource(radius=radius) points3d = tvtk.Glyph3D() points3d.set_source_connection(sphere.output_port) points3d.set_input_data(poly) m1 = tvtk.PolyDataMapper() m1.set_input_data(poly) a1 = tvtk.Actor(mapper=m1) a1.property.opacity = 0.3 m2 = tvtk.PolyDataMapper() m2.set_input_data(poly) a2 = tvtk.Actor(mapper=m2) a2.property.representation = "wireframe" a2.property.line_width = 2.0 a2.property.color = (1.0, 0, 0) m3 = tvtk.PolyDataMapper(input_connection=points3d.output_port) a3 = tvtk.Actor(mapper=m3) a3.property.color = (0.0, 1.0, 0.0) return [a1, a2, a3]
def __init__(self, triangles, points, scalars=None, **traits): """ Parameters ---------- - triangles : array This contains a list of vertex indices forming the triangles. - points : array Contains the list of points referred to in the triangle list. - scalars : array (optional) Scalars to associate with the points. """ super(FancyTriMesh, self).__init__(**traits) self.points = points self.pd = make_triangle_polydata(triangles, points, scalars) # Update the radii so the default is computed correctly. self._tube_radius_changed(self.tube_radius) self._sphere_radius_changed(self.sphere_radius) scalar_vis = self.scalar_visibility # Extract the edges and show the lines as tubes. self.extract_filter = tvtk.ExtractEdges(input=self.pd) extract_f = self.extract_filter self.tube_filter.trait_set(input=extract_f.output, radius=self.tube_radius) edge_mapper = tvtk.PolyDataMapper(input=self.tube_filter.output, lookup_table=self.lut, scalar_visibility=scalar_vis) edge_actor = _make_actor(mapper=edge_mapper) edge_actor.property.color = self.color # Create the spheres for the points. self.sphere_source.radius = self.sphere_radius spheres = tvtk.Glyph3D(scaling=0, source=self.sphere_source.output, input=extract_f.output) sphere_mapper = tvtk.PolyDataMapper(input=spheres.output, lookup_table=self.lut, scalar_visibility=scalar_vis) sphere_actor = _make_actor(mapper=sphere_mapper) sphere_actor.property.color = self.color if scalars is not None: rs = numpy.ravel(scalars) dr = min(rs), max(rs) self.lut.table_range = dr edge_mapper.scalar_range = dr sphere_mapper.scalar_range = dr self.actors.extend([edge_actor, sphere_actor])
def show_points(xyzs, colors=None, voxelize=False, res=0.05, polydata=None, vtkfiletag="visvtk", renderer=renderer): if polydata is None: polydata = tvtk.PolyData() #zMin = xyzs[:, 2].min() #zMax = xyzs[:, 2].max() #mapper.scalar_range = (zMin, zMax) #mapper.scalar_visibility = 1 polydata.points = xyzs # http://www.vtk.org/Wiki/VTK/Tutorials/GeometryTopology # VTK strongly divides GEOMETRY from TOPOLOGY. What most users would # think of as "points" are actually "points + vertices" in VTK. The # geometry is ALWAYS simply a list of coordinates - the topology # represents the connectedness of these coordinates. If no topology at # all is specified, then, as far as VTK is aware, there is NOTHING to # show. If you want to see points, you must tell VTK that each point # is independent of the rest by creating a vertex (a 0-D topology) at # each point. verts = np.arange(0, xyzs.shape[0], 1, 'l') # point ids verts.shape = (xyzs.shape[0], 1) # make it a column vector polydata.verts = verts if voxelize: cubesrc = tvtk.CubeSource() cubesrc.x_length = res cubesrc.y_length = res cubesrc.z_length = res glyph3d = tvtk.Glyph3D() glyph3d.source = cubesrc.output glyph3d.input = polydata glyph3d.update() polydata = glyph3d.output normals = compute_polydata_normals(polydata) color_polydata_by_normals(polydata, normals) else: if colors is None: colors = np.abs(xyzs[:, 2]/ np.max(xyzs[:, 2])) polydata.point_data.scalars = colors polydata.point_data.scalars.name = 'scalars' return visualise(polydata, vtkfiletag=vtkfiletag, renderer=renderer)
def test_glyph_pipeline(self): # Given rta = tvtk.RTAnalyticSource() cs = tvtk.ConeSource() g = tvtk.Glyph3D(input_connection=rta.output_port) g.set_source_connection(cs.output_port) m = tvtk.PolyDataMapper(input_connection=g.output_port) tg = self._make_tree_generator() # When/Then kids = tg.get_children(cs) self.assertEqual(len(kids), 0) kids = tg.get_children(rta) self.assertEqual(len(kids), 0) kids = tg.get_children(g) self.assertEqual(len(kids), 2) self.assertEqual(kids['input'], [rta, cs]) kids = tg.get_children(m) self.assertEqual(len(kids), 3) self.assertEqual(kids['input'], [g]) self.assertEqual(kids['lookup_table'], m.lookup_table)
# -*- coding: utf-8 -*- from .example_cut_plane import read_data import numpy as np from tvtk.api import tvtk from scpy2.tvtk.tvtkhelp import ivtk_scene, event_loop, make_outline plot3d = read_data() grid = plot3d.output.get_block(0) mask = tvtk.MaskPoints(random_mode=True, on_ratio=50) mask.set_input_data(grid) arrow_source = tvtk.ArrowSource() arrows = tvtk.Glyph3D(input_connection=mask.output_port, scale_factor=2 / np.max(grid.point_data.scalars.to_array())) arrows.set_source_connection(arrow_source.output_port) arrows_mapper = tvtk.PolyDataMapper(scalar_range=grid.point_data.scalars.range, input_connection=arrows.output_port) arrows_actor = tvtk.Actor(mapper=arrows_mapper) center = grid.center 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))
# point_data.t_coords = <array>. # # In this case CubeSource already defines texture coords for us (as of # VTK-4.4). cs = tvtk.CubeSource(x_length=2, y_length=1.0, z_length=0.5) # Create input for the glyph -- the sources are placed at these input # points. pts = [[1, 1, 1], [0, 0, 0], [-1, -1, -1]] pd = tvtk.PolyData(points=pts, polys=[[0], [1], [2]]) # Orientation/scaling is as per the vector attribute. vecs = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] pd.point_data.vectors = vecs # Create the glyph3d and set up the pipeline. g = tvtk.Glyph3D(scale_mode='data_scaling_off', vector_mode='use_vector') configure_input_data(g, pd) # Note that VTK's vtkGlyph.SetSource is special because it has two # call signatures: SetSource(src) and SetSource(int N, src) (which # sets the N'th source). In tvtk it is represented as both a property # and as a method. Using the `source` property will work fine if all # you want is the first `source`. OTOH if you want the N'th `source` # use get_source(N). # g.source = cs.output configure_source_data(g, cs.output) cs.update() g.update() m = tvtk.PolyDataMapper() configure_input_data(m, g.output)
from tvtk.api import tvtk from CStvtkfunc import ivtk_scene, event_loop #读入PLot3D数据 plot3d = tvtk.MultiBlockPLOT3DReader(xyz_file_name="Element\combxyz.bin", q_file_name="Element\combq.bin", scalar_function_number=100, vector_function_number=200) plot3d.update() grid = plot3d.output.get_block(0) #对数据集中的数据进行随机选取,每50个点选择一个点 mask = tvtk.MaskPoints(random_mode=True, on_ratio=50) mask.set_input_data(grid) #创建表示箭头的PolyData数据集 glyph_source = tvtk.ConeSource() #在Mask采样后的PolyData数据集每个点上放置一个箭头 #箭头的方向、长度和颜色由于点对应的矢量和标量数据决定 glyph = tvtk.Glyph3D(input_connection=mask.output_port, scale_factor=2) glyph.set_source_connection(glyph_source.output_port) m = tvtk.PolyDataMapper(scalar_range=grid.point_data.scalars.range, input_connection=glyph.output_port) a = tvtk.Actor(mapper=m) #窗口绘制 win = ivtk_scene(a) 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 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()