def test_contours():
from enthought.tvtk.api import tvtk
from numpy import *
import pickle,numpy
from openravepy import *
env = Environment()
env.SetViewer('qtcoin')
N = 50
Nj = N*(0+1j)
x, y, z = numpy.mgrid[-10:10:Nj, -10:20:Nj, -10:40:Nj]
scalars = x*x + 2.0*y*y + z*z/2.0
spacing=array((0.005,0.005,0.005))
id = tvtk.ImageData(origin=array((numpy.min(x),numpy.min(y),numpy.min(z))),spacing=spacing,dimensions=scalars.shape)
id.point_data.scalars = scalars.ravel()
with open('tris.pp','r') as f:
x,y,z,t,sweptdata = pickle.load(f)
sweptdata = array(sweptdata,'float64')
#sweptdata = sweptdata[0:61,0:60,0:60]
id = tvtk.ImageData(origin=array((0,0,0)),spacing=array((0.005,0.005,0.005)),dimensions=sweptdata.shape[::-1])
id.point_data.scalars = 100.0*sweptdata.ravel()
m = tvtk.MarchingCubes()
m.set_input(id)
m.set_value(0,0.5)
m.update()
o = m.get_output()
newpoints = array(o.points)
h = env.plot3 (points=newpoints,pointsize=2.0,colors=array((1,0,0)))
indices = array(o.polys.data)
indices = array(reshape(indices,(int(len(indices)/4),4)),'int')
h2 = env.drawtrimesh (points=newpoints,indices=indices[:,1:4],colors=array((0,0,1,0.5)))
def _update_image_data_fired(self):
sp = tuple(self.spacing)
o = tuple(self.origin)
self.image_data = tvtk.ImageData(spacing=sp, origin=o)
sd = self.scalar_data
if sd is not None:
self._scalar_data_changed(sd)
def image_data():
data = random.random((3, 3, 3))
i = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
i.point_data.scalars = data.ravel()
i.point_data.scalars.name = 'scalars'
i.dimensions = data.shape
return i
def __init__(self, **kw_args):
super(PPCoordSource, self).__init__(**kw_args)
fn=kw_args.pop('file_name', None)
dir=os.path.dirname(self.file_name)
phparams=os.path.join(dir, "phasingparams.py")
engine=kw_args.pop('engine', None)
self.engine.add_trait('dataarrays', Dict)
self.engine.add_trait('coords', Dict)
if self.engine.coords.has_key(phparams):
self.coords=self.engine.coords[phparams]
else:
self.engine.coords[phparams]=cs.CoordSystem()
self.coords=self.engine.coords[phparams]
self.coords.exec_param_file(phparams)
self.coords.on_trait_change(self._coords_changed, 'T')
if fn is not None:
self.file_name= fn
self._open(self.file_name)
dims=self.dataarray.shape
print "init coords update start"
self.coords.UpdateCoordSystem(dims)
print "init coords update end"
self.sg=tvtk.StructuredGrid()
self.im=tvtk.ImageData()
self.component="Real"
self._component_changed('Real') #can change this for a different default
def test_image_data_scalar_type(self):
"Does ImageData support all scalar types?"
img = tvtk.ImageData()
# There are 22 scalar types in VTK-5.2. We should be able to
# use them all.
for i in range(0, 22):
img.scalar_type = i
def setUp(self):
datasets = [
tvtk.ImageData(),
tvtk.StructuredPoints(),
tvtk.RectilinearGrid(),
tvtk.StructuredGrid(),
tvtk.PolyData(),
tvtk.UnstructuredGrid(),
]
exts = ['.vti', '.vti', '.vtr', '.vts', '.vtp', '.vtu']
self.datasets = datasets
self.exts = exts
def make_grid4scatter(self):
src = VTKDataSource()
xmin, xmax, dx = 100, 200, 2
nx = int((xmax - xmin) / dx) + 1
ymin, ymax, dy = 100, 200, 2
ny = int((ymax - ymin) / dy) + 1
zmin, zmax, dz = 100, 200, 2
nz = int((zmax - zmin) / dz) + 1
image_data = tvtk.ImageData(origin=(xmin, ymin, zmin),
spacing=(dx, dy, dz),
extent=(0, nx - 1, 0, ny - 1, 0, nz - 1))
image_data.whole_extent = image_data.extent
src.data = image_data
return src
def test_tvtk_dataset_name(self):
"Can tvtk datasets can be converted to names correctly."
datasets = [
tvtk.ImageData(),
tvtk.StructuredPoints(),
tvtk.RectilinearGrid(),
tvtk.StructuredGrid(),
tvtk.PolyData(),
tvtk.UnstructuredGrid(),
tvtk.Property(), # Not a dataset!
'foo', # Not a TVTK object.
]
expect = [
'image_data', 'image_data', 'rectilinear_grid', 'structured_grid',
'poly_data', 'unstructured_grid', 'none', 'none'
]
result = [pipeline_info.get_tvtk_dataset_name(d) for d in datasets]
self.assertEqual(result, expect)
def image_from_array(ary):
""" Create a VTK image object that references the data in ary.
The array is either 2D or 3D with. The last dimension
is always the number of channels. It is only tested
with 3 (RGB) or 4 (RGBA) channel images.
Note: This works no matter what the ary type is (accept
probably complex...). uint8 gives results that make since
to me. Int32 and Float types give colors that I am not
so sure about. Need to look into this...
"""
sz = ary.shape
dims = len(sz)
# create the vtk image data
img = tvtk.ImageData()
if dims == 2:
# 1D array of pixels.
img.whole_extent = (0, sz[0]-1, 0, 0, 0, 0)
img.dimensions = sz[0], 1, 1
img.point_data.scalars = ary
elif dims == 3:
# 2D array of pixels.
img.whole_extent = (0, sz[0]-1, 0, sz[1]-1, 0, 0)
img.dimensions = sz[0], sz[1], 1
# create a 2d view of the array
ary_2d = ary[:]
ary_2d.shape = sz[0]*sz[1],sz[2]
img.point_data.scalars = ary_2d
else:
raise ValueError, "ary must be 3 dimensional."
return img
def setUp(self):
# Create dataset with multiple scalars.
arr1 = zeros(27, 'f')
for n in range(27):
arr1[n] = (1 + float(n)) / 10.0
arr2 = (arr1 + 1).astype('d')
arr3 = arr1 + 2.0 * (0.5 - random.random(27))
arr3 = arr3.astype('f')
p = tvtk.ImageData(dimensions=[3, 3, 3],
spacing=[1, 1, 1],
scalar_type='int')
p.point_data.scalars = arr1
p.point_data.scalars.name = 'first'
j2 = p.point_data.add_array(arr2)
p.point_data.get_array(j2).name = 'second'
j3 = p.point_data.add_array(arr3)
p.point_data.get_array(j3).name = 'third'
p.update()
self.img = p
self.first = arr1
self.second = arr2
self.third = arr3
# Setup the mayavi pipeline.
e = NullEngine()
e.start()
e.new_scene()
self.e = e
src = VTKDataSource(data=p)
e.add_source(src)
self.src = src
ipw = ImagePlaneWidget()
e.add_module(ipw)
self.ipw = ipw
def do(self):
############################################################
# Imports.
script = self.script
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.api import ImagePlaneWidget
# Create dataset with multiple scalars.
arr1 = zeros(27, 'f')
for n in range(27):
arr1[n] = (1 + float(n)) / 10.0
arr2 = (arr1 + 1).astype('d')
arr3 = arr1 + 2.0 * (0.5 - random.random(27))
arr3 = arr3.astype('f')
p = tvtk.ImageData(dimensions=[3, 3, 3],
spacing=[1, 1, 1],
scalar_type='int')
p.point_data.scalars = arr1
p.point_data.scalars.name = 'first'
j2 = p.point_data.add_array(arr2)
p.point_data.get_array(j2).name = 'second'
j3 = p.point_data.add_array(arr3)
p.point_data.get_array(j3).name = 'third'
p.update()
# Make the pipeline.
self.new_scene()
src = VTKDataSource(data=p)
script.add_source(src)
ipw = ImagePlaneWidget()
script.add_module(ipw)
# Test.
ipw = ipw.ipw
scalars = ipw.input.point_data.scalars
r = scalars.range
expect = min(arr1), max(arr1)
assert r == expect
o = src.outputs[0]
o.update_traits()
st = ipw.input.scalar_type
assert scalars.data_type == 10
assert st == 'float'
src.point_scalars_name = 'second'
scalars = ipw.input.point_data.scalars
r = scalars.range
expect = min(arr2), max(arr2)
assert r == expect
o.update_traits()
st = ipw.input.scalar_type
assert scalars.data_type == 11
assert st == 'double'
src.point_scalars_name = 'third'
scalars = ipw.input.point_data.scalars
r = scalars.range
expect = min(arr3), max(arr3)
assert r == expect
o.update_traits()
st = ipw.input.scalar_type
assert scalars.data_type == 10
assert st == 'float'
# -*- coding: utf-8 -*-
from enthought.tvtk.api import tvtk
import numpy as np
img = tvtk.ImageData(spacing=(0.1, 0.1, 0.1),
origin=(0.1, 0.2, 0.3),
dimensions=(3, 4, 5))
img.point_data.scalars = np.arange(0.0, img.number_of_points)
img.point_data.scalars.name = 'scalars'
import numpy as np
from enthought.tvtk.api import tvtk, write_data
data = np.random.random((10, 10, 10))
grid = tvtk.ImageData(spacing=(10, 5, -10),
origin=(100, 350, 200),
dimensions=data.shape)
grid.point_data.scalars = np.ravel(order='F')
grid.point_data.scalars.name = 'Test Data'
# Writes legacy ".vtk" format if filename ends with "vtk", otherwise
# this will write data using the newer xml-based format.
write_data(grid, 'test.vtk')
lines = [[0,4],[4,5]]
data = tvtk.PolyData(points=points, polys=cells, lines=lines)
data.point_data.scalars = numpy.linspace(-5,5,6)
lm = LUTManager()
#lm.configure_traits()
map = tvtk.PolyDataMapper(input=data)
map.lookup_table = lm.lut
act = tvtk.Actor(mapper=map)
x,y = numpy.ogrid[-5:5:0.1, -5:5:0.1]
r = x**2 + y**2
z = numpy.cos(r*2) * numpy.exp(-r/3)
img = tvtk.ImageData(origin=(2,2,2), spacing=(0.1,0.1,0.1),
dimensions = (z.shape[0], z.shape[1],1 ))
img.point_data.scalars=z.ravel()
img_poly = tvtk.GeometryFilter(input=img)
warp = tvtk.WarpScalar(input_connection=img_poly.output_port)
norm = tvtk.PolyDataNormals(input_connection = warp.output_port)
img_map = tvtk.PolyDataMapper(input_connection=norm.output_port)
img_act = tvtk.Actor(mapper=img_map)
ren = tvtk.Renderer()
#ren.add_actor(act)
ren.add_actor(img_act)
renwin = tvtk.RenderWindow()
renwin.add_renderer(ren)
iren = tvtk.RenderWindowInteractor(render_window=renwin)
def _image_data_default(self):
s = tuple(self.spacing)
o = tuple(self.origin)
return tvtk.ImageData(spacing=s, origin=o)
