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.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 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
#
# 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',
input=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
m = tvtk.PolyDataMapper(input=g.output)
a = tvtk.Actor(mapper=m)
# Read the texture from image and set the texture on the actor. If
# you don't like this image, replace with your favorite -- any image
def _setup_scene(self):
# scalar bar for strain
lut_strain = tvtk.LookupTable(hue_range=(0.66, 0.0))
lut_strain.build()
self._scalar_bar_strain = tvtk.ScalarBarActor(
lookup_table=lut_strain,
orientation='horizontal',
text_position='succeed_scalar_bar',
maximum_number_of_colors=256,
number_of_labels=9,
position=(0.1, 0.01),
position2=(0.8, 0.08),
title='element strain (%)',
visibility=False)
self.scene.add_actor(self._scalar_bar_strain)
# scalar bar for stress
# lookup table from green to yellow, and last 2 values dark red
lut_stress = tvtk.LookupTable(hue_range=(0.33, 0.1),
number_of_table_values=256)
lut_stress.build()
lut_stress.set_table_value(254, (1.0, 0.4, 0.0, 1.0))
lut_stress.set_table_value(255, (1.0, 0.0, 0.0, 1.0))
self._scalar_bar_stress = tvtk.ScalarBarActor(
lookup_table=lut_stress,
orientation='horizontal',
text_position='succeed_scalar_bar',
maximum_number_of_colors=256,
number_of_labels=9,
position=(0.1, 0.01),
position2=(0.8, 0.08),
title='element stress',
visibility=False)
self.scene.add_actor(self._scalar_bar_stress)
# setup elements visualization
self._elements_polydata = tvtk.PolyData()
self._tubes = tvtk.TubeFilter(
input=self._elements_polydata,
number_of_sides=6,
vary_radius='vary_radius_by_absolute_scalar',
radius_factor=1.5)
mapper = tvtk.PolyDataMapper(input=self._tubes.output,
lookup_table=lut_strain,
interpolate_scalars_before_mapping=True,
scalar_mode='use_cell_data')
self._elements_actor = tvtk.Actor(mapper=mapper)
self.scene.add_actor(self._elements_actor)
# show elements in deformed state as wireframe
self._deformed_elements_polydata = tvtk.PolyData()
self._deformed_elements_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=self._deformed_elements_polydata))
self._deformed_elements_actor.property.set(opacity=0.2,
representation='wireframe')
self.scene.add_actor(self._deformed_elements_actor)
# highlight one element via a ribbon outline
self._hl_element_ribbons = tvtk.RibbonFilter(input=tvtk.PolyData(),
use_default_normal=True,
width=1.0)
self._hl_element_actor = tvtk.Actor(
mapper=tvtk.PolyDataMapper(input=self._hl_element_ribbons.output),
visibility=False)
self._hl_element_actor.property.set(ambient=1,
ambient_color=(1, 1, 1),
diffuse=0)
self.scene.add_actor(self._hl_element_actor)
# cross sectional radius labels
self._elements_label_polydata = tvtk.PolyData()
self._label_cellcenters = tvtk.CellCenters(
input=self._elements_label_polydata)
self._label_visps = tvtk.SelectVisiblePoints(
renderer=self.scene.renderer,
input=self._label_cellcenters.output,
tolerance=10000)
self._label_actor = tvtk.Actor2D(mapper=tvtk.Dynamic2DLabelMapper(
input=self._label_visps.output, label_mode='label_scalars'))
self._label_actor.mapper.label_text_property.set(
bold=True, italic=False, justification='centered', font_size=14)
#self.scene.add_actor(self._label_actor)
# force glyphs (use arrows for that)
self._force_glyphs = tvtk.Glyph3D(scale_mode='scale_by_vector',
vector_mode='use_vector',
color_mode='color_by_vector',
scale_factor=1.)
self._force_glyphs.set_source(
0,
tvtk.ArrowSource(shaft_radius=0.04,
tip_resolution=8,
tip_radius=0.2).output)
self._force_polydata = tvtk.PolyData()
self._force_glyphs.set_input(0, self._force_polydata)
self._force_actor = tvtk.Actor(mapper=tvtk.PolyDataMapper(
input=self._force_glyphs.output, scalar_range=(0, 10)))
self._force_actor.mapper.lookup_table.hue_range = (0.33, 0.0)
self.scene.add_actor(self._force_actor)
# current status display
self._text_actor = tvtk.TextActor(position=(0.5, 0.95))
self._text_actor.position_coordinate.coordinate_system = 'normalized_display'
self._text_actor.text_property.set(font_size=14,
justification='center')
self.scene.add_actor(self._text_actor)
# a nice gradient background
self.scene.renderer.set(background2=(0.28, 0.28, 0.28),
background=(0.01, 0.01, 0.02),
gradient_background=True)
# setup events
self.interaction_mode = 'select'
self.scene.interactor.add_observer('MouseMoveEvent', self._mouse_move)
self.scene.interactor.add_observer('LeftButtonPressEvent',
self._mouse_press)
self.scene.renderer.add_observer('StartEvent', self._before_render)
self._on_init = True
self._reset_zoom_needed = True
resizable=True, width=700, height=600
)
if __name__=="__main__":
graph = tvtk.RandomGraphSource()
layout = tvtk.GraphLayout(input_connection=graph.output_port,
layout_strategy=tvtk.Simple2DLayoutStrategy())
poly = tvtk.GraphToPolyData(input_connection=layout.output_port)
s = tvtk.SphereSource()
glyph = tvtk.Glyph3D(input_connection=poly.output_port,
source=s.output)
app = tvtk.AppendPolyData()
app.add_input_connection(glyph.output_port)
app.add_input_connection(poly.output_port)
map = tvtk.PolyDataMapper(input_connection=app.output_port)
act = tvtk.Actor(mapper=map)
demo = ActorView()
demo.scene.add_actor(act)
demo.configure_traits()
# -*- coding: utf-8 -*-
import numpy as np
from enthought.tvtk.api import tvtk
from utility import show_actors
from tvtk_cut_plane import read_data
# 读入数据
plot3d = read_data()
# 矢量箭头
mask = tvtk.MaskPoints(input = plot3d.output, random_mode=True, on_ratio=50)
arrow_source = tvtk.ArrowSource()
arrows = tvtk.Glyph3D(input = mask.output, source=arrow_source.output,
scale_factor=2/np.max(plot3d.output.point_data.scalars.to_array()))
arrows_mapper = tvtk.PolyDataMapper(input = arrows.output,
scalar_range = plot3d.output.point_data.scalars.range)
arrows_actor = tvtk.Actor(mapper = arrows_mapper)
# 作为流线起点的球
center = plot3d.output.center
sphere = tvtk.SphereSource(
center=(2, center[1], center[2]), radius=2,
phi_resolution=6, theta_resolution=6)
sphere_mapper = tvtk.PolyDataMapper(input = sphere.output)
sphere_actor = tvtk.Actor(mapper = sphere_mapper)
sphere_actor.property.set(
representation = "wireframe", color=(0,0,0))
# 流线