def Atest_subaperture_imaging(self):
target_car = "MazdaMPV"
path_to_data = "/mnt/media/data/3D_rec/out/out_" + target_car
elevs = np.arange(30, 60, 0.125)
img = np.zeros((51, 31, 121))
azim_start = '%03d' % 0
azim_end = '%03d' % 5
for elev in elevs:
elev_str = format(elev, '.4f')
filename = "_".join([
"img", "out", elev_str, "minaz", azim_start, "maxaz", azim_end
]) + ".npy"
file_path = os.path.join(path_to_data, filename)
np_data = np.load(file_path)
img = img + np_data
# azim_start = '%03d' % 5
# azim_end = '%03d' % 10
# for elev in elevs:
# elev_str = format(elev, '.4f')
# filename = "_".join(["img", "out", elev_str, "minaz", azim_start, "maxaz", azim_end]) + ".npy"
# file_path = os.path.join(path_to_data, filename)
# np_data = np.load(file_path)
# img = img + np_data
img = np.abs(img)
fimg = np.concatenate((img[:, ::-1, :], img), axis=1)
from tvtk.api import tvtk, write_data
grid = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
grid.point_data.scalars = fimg.ravel("F")
grid.point_data.scalars.name = "subApertureTest"
grid.dimensions = fimg.shape
write_data(grid, "/home/wshong/Documents/subApertureTest.vtk")
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 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 write_simple(arr, filename):
from tvtk.api import tvtk, write_data
id = tvtk.ImageData()
id.point_data.scalars = abs(arr.ravel(order='F'))
id.dimensions = arr.shape
write_data(id, filename)
def _render_mesh(self,
mesh_type="surface",
ambient_light=0.0,
specular_light=0.0,
alpha=1.0):
from tvtk.api import tvtk
pd = tvtk.PolyData()
pd.points = self.points
pd.polys = self.trilist
pd.point_data.t_coords = self.tcoords_per_point
mapper = tvtk.PolyDataMapper()
mapper.set_input_data(pd)
p = tvtk.Property(
representation=mesh_type,
opacity=alpha,
ambient=ambient_light,
specular=specular_light,
)
actor = tvtk.Actor(mapper=mapper, property=p)
# Get the pixels from our image class which are [0, 1] and scale
# back to valid pixels. Then convert to tvtk ImageData.
texture = self.texture.pixels_with_channels_at_back(out_dtype=np.uint8)
if self.texture.n_channels == 1:
texture = np.stack([texture] * 3, axis=-1)
image_data = np.flipud(texture).ravel()
image_data = image_data.reshape([-1, 3])
image = tvtk.ImageData()
image.point_data.scalars = image_data
image.dimensions = self.texture.width, self.texture.height, 1
texture = tvtk.Texture()
texture.set_input_data(image)
actor.texture = texture
self.figure.scene.add_actors(actor)
self._actors.append(actor)
def _save_mgrid_vtk(result, outfile, **kwds):
'''
Save a result defined on a meshgrid to a VTK file
'''
from tvtk.api import tvtk
from tvtk.api import write_data
arrs = result.array_data_by_type()
mgrid = arrs['mgrid']
shape = mgrid[0].shape
linspaces = mgrid_to_linspace(mgrid, expand=False)
origin = list()
spacing = list()
for ls in linspaces:
print "ls: %s" % str(ls)
origin.append(ls[0])
spacing.append((ls[1] - ls[0]) / ls[2])
print 'origin: %s' % str(origin)
print 'spacing: %s' % str(spacing)
print 'dimensions: %s' % str(shape)
dat = tvtk.ImageData(spacing=spacing, origin=origin, dimensions=shape)
scalar = arrs.get('gscalar', None)
if scalar is not None:
dat.point_data.scalars = scalar.ravel(order='F')
dat.point_data.scalars.name = "gscalar" # fixme, should use name, not type?
vector = arrs.get('gvector', None)
if vector is not None:
dat.point_data.vectors = numpy.asarray(
[vector[i].ravel(order='F') for i in range(3)]).T
dat.point_data.vectors.name = "gvector"
write_data(dat, outfile)
return
def marching_cubes(volume, smooth=True, decimate=True, **kwargs):
from tvtk.api import tvtk
from tvtk.common import configure_input
imgdata = tvtk.ImageData(dimensions=volume.shape)
imgdata.point_data.scalars = volume.flatten('F')
contours = tvtk.ContourFilter(number_of_contours=1)
contours.set_value(0, 1)
configure_input(contours, imgdata)
if smooth:
smoothargs = dict(number_of_iterations=40,
feature_angle=90,
pass_band=.05)
smoothargs.update(kwargs)
contours = tvtk.WindowedSincPolyDataFilter(input=contours.output,
**smoothargs)
if decimate:
contours = tvtk.QuadricDecimation(input=contours.output,
target_reduction=.75)
contours.update()
pts = contours.output.points.to_array()
polys = contours.output.polys.to_array().reshape(-1, 4)[:, 1:]
return pts, polys
def StructuredVector(InputArray, OutFileName, lim1, lim2):
nGr = np.shape(InputArray)[:, :, :, 0][0]
nx1IC = ny1 = nz1 = int(lim1)
nx2IC = ny2 = nz2 = int(lim2)
im = jm = km = nGr * 1j
nf0 = nf1 = nf2 = nGr
Xg, Yg, Zg = np.mgrid[nx1IC:nx2IC:im, ny1:ny2:jm, nz1:nz2:km]
# Make the data.
dims = np.array((nf0, nf1, nf2))
vol = np.array((lim1, lim2, lim1, lim2, lim1, lim2))
origin = vol[::2]
spacing = (vol[1::2] - origin) / (dims - 1)
xmin, xmax, ymin, ymax, zmin, zmax = vol
x, y, z = np.ogrid[xmin:xmax:dims[0] * 1j, ymin:ymax:dims[1] * 1j,
zmin:zmax:dims[2] * 1j]
x, y, z = [t.astype('f') for t in (x, y, z)]
i = tvtk.ImageData(origin=origin, spacing=spacing, dimensions=dims)
i.point_data.scalars = InputArray[:, :, :, 0].ravel()
i.point_data.scalars.name = 'v0'
i.dimensions = InputArray[:, :, :, 0].shape
# add second point data field
i.point_data.add_array(InputArray[:, :, :, 1].ravel())
i.point_data.get_array(1).name = 'v1'
i.point_data.update()
i.point_data.add_array(InputArray[:, :, :, 2].ravel())
i.point_data.get_array(2).name = 'v2'
i.point_data.update()
fileOut = OutFileName + '.vtk'
print fileOut
write_data(i, fileOut)
def save_as_vtk(fn,X_grid,
voxel_coords):
'''
Save 4d arrays in VTK
Parameters
----------
fn : string
Filename
X_grid : ndarray
4d array of injections aligned to grid
voxel_coords : ndarray
num_voxel x 3 array of x,y,z coordinates
'''
from tvtk.api import tvtk, write_data
if X_grid.ndim == 4:
grid_shape=X_grid[:,:,:,0].shape
num_rows=np.prod(grid_shape)
num_virt=X_grid.shape[3]
else:
raise Exception("need 4d arrays for X_grid")
VTK=tvtk.ImageData(spacing=(1,1,1),
origin=np.min(voxel_coords,axis=0),
dimensions=grid_shape)
VTK.point_data.scalars= np.arange(0,num_rows)
VTK.point_data.scalars.name='voxel number'
for n in range(num_virt):
a=VTK.point_data.add_array(X_grid[:,:,:,n].ravel(order='F'))
VTK.point_data.get_array(a).name="X%04d" % n
VTK.point_data.update()
del a
write_data(VTK,fn)
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 save_field_to_disk(field, file_path, spacing=(1, 1, 1)):
"""
save a vector field to a .vtk file
:param field: field to save
:param file_path: path to use
:param spacing: voxel spacing
"""
try:
spacing = spacing.numpy()
except:
pass
field_x, field_y, field_z = field[0], field[1], field[2]
vectors = np.empty(field_x.shape + (3, ), dtype=float)
vectors[..., 0], vectors[..., 1], vectors[...,
2] = field_x, field_y, field_z
vectors = vectors.transpose(2, 1, 0, 3).copy(
) # NOTE (DG): reorder the vectors per VTK requirement of x first, y next and z last
vectors.shape = vectors.size // 3, 3
im_vtk = tvtk.ImageData(spacing=spacing,
origin=(0, 0, 0),
dimensions=field_x.shape)
im_vtk.point_data.vectors = vectors
im_vtk.point_data.vectors.name = 'field'
write_data(im_vtk, file_path)
def image_to_vtk_texture(img):
imgdata = tvtk.ImageData()
t = img[::-1].reshape(-1, 3).astype(np.uint8)
imgdata.point_data.scalars = t
imgdata.extent = (0, img.shape[0] - 1, 0, img.shape[1] - 1, 0, 0)
imgdata.dimensions = (img.shape[1], img.shape[0], 1)
vtk_texture = tvtk.Texture()
configure_input_data(vtk_texture, imgdata)
return vtk_texture
def test_parent_child_input(self):
"""Case where parent has GetInput and child SetInput."""
vm = tvtk.SmartVolumeMapper()
# In this case if the wrapping is not done right, the input
# trait is made read-only which is a bug. We set the input
# below to test this.
configure_input_data(vm, tvtk.ImageData())
spw = tvtk.StructuredPointsWriter()
spw.input_connection = None
def test_image_data_scalar_type(self):
"""Does ImageData support all scalar types?.
Setting scalar type is no longer supported on VTK 6."""
if vtk_major_version < 6:
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 image_data(vmesh):
data = denseMatrix(vmesh)
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 test_get_range_works_for_VTKNoneArray(self):
id_ = tvtk.ImageData(dimensions=(2, 2, 1), origin=(0, 0, 0),
spacing=(1, 1, 1))
id_.point_data.scalars = np.arange(4, dtype=float)
dsh = DataSetHelper(id_)
self.assertFalse(dsh._composite)
self.assertEqual(dsh.get_range(), (None, [0., 1.]))
# XXX there is some wackiness here, no idea why this changes!
self.assertEqual(dsh.get_range(), ('point_scalars', [0., 3.]))
def test_parent_child_input(self):
"""Case where parent has GetInput and child SetInput."""
vm = tvtk.VolumeTextureMapper2D()
# In this case if the wrapping is not done right, the input
# trait is made read-only which is a bug. We set the input
# below to test this.
vm.input = tvtk.ImageData()
spw = tvtk.StructuredPointsWriter()
spw.input = None
def show_img(img, renderer=renderer):
img_data = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
img_data.point_data.scalars, img_data.dimensions = vtkimage_from_array(img)
img_actor = tvtk.ImageActor()
img_actor.set_input_data(img_data)
img_actor.rotate_wxyz(45, 1, 0, 0)
renderer.add_actor(img_actor)
return img_actor
def genSurface(data, fname):
from tvtk.api import tvtk
grid = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
grid.point_data.scalars = data.T.ravel() # It wants fortran order???
grid.point_data.scalars.name = 'scalars'
grid.dimensions = data.shape
iso = tvtk.ImageMarchingCubes(input=grid)
w = tvtk.PolyDataWriter(
input=iso.output, file_name=os.path.join(model_path, fname))
w.write()
def _image_data_from_array(array, spacing):
""" Build an ImageData object from a numpy array.
"""
image_data = tvtk.ImageData()
image_data.spacing = spacing
image_data.dimensions = array.shape
image_data.point_data.scalars = array.ravel('F')
image_data.point_data.scalars.name = POINT_DATA_SCALARS_NAME
return image_data
def _make_data(self, factor=1.0):
id = tvtk.ImageData(dimensions=(2, 2, 1), origin=(0, 0, 0),
spacing=(1, 1, 1))
id.point_data.scalars = np.arange(4, dtype=float)*factor
id.point_data.scalars.name = 'ps'
id.point_data.vectors = np.ones((4, 3), dtype=float)*factor
id.point_data.vectors.name = 'pv'
id.cell_data.scalars = np.arange(4, dtype=float)*0.5*factor
id.cell_data.scalars.name = 'cs'
id.cell_data.vectors = np.ones((4, 3), dtype=float)*0.5*factor
id.cell_data.vectors.name = 'cv'
return id
def plot_bool_mask(mask):
from tvtk.api import tvtk
from mayavi import mlab
X, Y, Z = np.mgrid[-10:10:256j, -10:10:256j, -10:10:256j]
data = mask.astype("float")
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
mlab.pipeline.surface(i)
mlab.colorbar(orientation='vertical')
mlab.show()
def convert_np_to_vtk(path_to_np, path_to_save_vtk, name):
np_data = np.load(path_to_np)
np_data = normalization_3d(np_data)
# show_volume(np_data)
from tvtk.api import tvtk, write_data
grid = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
grid.point_data.scalars = np_data.ravel("F")
grid.point_data.scalars.name = name
grid.dimensions = np_data.shape
write_data(grid, path_to_save_vtk)
def do(self):
############################################################
# Imports.
script = self.script
from mayavi.sources.vtk_data_source import VTKDataSource
from 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])
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'
# 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()
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()
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()
def save(data1, qq):
""" Q data, 'name of file'"""
#create the grid and create first data set
grid = tvtk.ImageData(spacing=data1.shape,
origin=(0, 0, 0),
dimensions=data1.shape)
grid.point_data.scalars = np.ravel(data1, order='F')
grid.point_data.scalars.name = 'Q method'
#write the data
write_data(grid, qq + '.vtk')
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))
src.data = image_data
return src
def read_and_plot_mask(meta):
DATAFIELD_NAME1 = 'Flag Mask'
maskhdf = meta.select(DATAFIELD_NAME1)
mask = np.array(maskhdf[:, :, :])
data = mask
i = tvtk.ImageData(spacing=(2, 2, 2), origin=(0, 0, 0))
i.point_data.scalars = data.ravel()
i.point_data.scalars.name = 'scalars'
i.dimensions = data.shape
mlab.pipeline.surface(i)
mlab.colorbar(orientation='vertical')
mlab.show()
return mask
def _poly_data_to_volume(data, voxel_size, margins):
"""
Render the given, closed <tvtk.PolyData> into an image volume and return it
as a Numpy array.
"""
# Following [*] for the necessary steps.
#
# References
# [*] http://www.paraview.org/Wiki/VTK/Examples/Cxx/PolyData/PolyDataToImageData (20150710)
# Calculate the necessary number of voxels, extent, and origin
bounds = np.array(data.bounds)
n_vox = np.ceil(
(bounds[1::2] - bounds[0::2] + np.sum(margins.reshape(2, 3), axis=0)) /
voxel_size).astype(np.int)
extent = [0, n_vox[0] - 1, 0, n_vox[1] - 1, 0, n_vox[2] - 1]
origin = bounds[0::2] - margins[:3] + 0.5 * voxel_size
# Create the image volume
volume = tvtk.ImageData(spacing=voxel_size,
dimensions=n_vox,
extent=extent,
origin=origin)
if is_old_pipeline():
volume.scalar_type = "unsigned_char"
voxel_data = (np.ones(n_vox, dtype=np.uint8) * 100).ravel()
volume.point_data.scalars = voxel_data
if is_old_pipeline():
volume.update()
# Actual transformation from polygon to image data
voxelizer = tvtk.PolyDataToImageStencil(output_origin=origin,
output_spacing=voxel_size,
output_whole_extent=volume.extent,
tolerance=0.0)
configure_input(voxelizer, data)
voxelizer.update()
# Draw the result to a new image, extract Numpy array and return
painter = tvtk.ImageStencil(reverse_stencil=False, background_value=0)
configure_input(painter, volume)
if is_old_pipeline():
painter.stencil = voxelizer.output
else:
painter.set_stencil_connection(voxelizer.output_port)
painter.update()
voxel_data = painter.output.point_data.scalars.to_array().reshape(
n_vox[::-1])
voxel_data = np.transpose(voxel_data, [2, 1, 0])
return voxel_data
def clusters2views(gr):
from tvtk.api import tvtk, write_data
class Perwpid:
def __init__(self):
self.allind = list()
self.allchs = list()
self.values = list()
perwpid = defaultdict(Perwpid)
for node, ndata in gr.nodes.data():
if ndata['code'] != 'm':
continue
bnode = get_blob(gr, node)
if bnode is None:
raise ValueError("bad graph structure")
#x = gr.nodes[bnode]['corners'][0][0] # "t"
#eckses.append(x)
snode = get_slice(gr, bnode)
if snode is None:
raise ValueError("bad graph structure")
wpid = ndata['wpid']
sdat = gr.nodes[snode]
snum = sdat['ident']
perwpid[wpid].allind.append(snum)
sact = sdat['activity']
val = 0.0
chids = ndata['chids']
perwpid[wpid].allchs += chids
for chid in chids:
val += float(sact[str(chid)])
perwpid[wpid].values.append((snum, chids, val))
all_imgdat = dict()
for wpid, dat in perwpid.items():
smin = min(dat.allind)
smax = max(dat.allind)
cmin = min(dat.allchs)
cmax = max(dat.allchs)
arr = numpy.zeros((smax - smin + 1, cmax - cmin + 1))
for ind, chids, val in dat.values:
for ch in chids:
arr[ind - smin, ch - cmin] += val
imgdat = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
imgdat.point_data.scalars = arr.T.flatten()
imgdat.point_data.scalars.name = 'activity'
imgdat.dimensions = list(arr.shape) + [1]
all_imgdat[wpid] = imgdat
return all_imgdat
