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 write_file(self, step=0):
# We will create the directory only when writing the file
if not os.path.isdir(self.directory):
os.makedirs(self.directory)
filename = "{}_{:06}".format(self.filename, step)
write_data(self.grid, os.path.join(self.directory, filename))
def update(self, U, t):
ts = self.tloop.ts
fets = ts.fets
n_c = fets.n_nodal_dofs
mats = ts.mats
DELTA_ab = fets.vtk_expand_operator
U_Ia = U.reshape(-1, n_c)
U_Eia = U_Ia[ts.I_Ei]
U_vector_field = np.einsum('Ia,ab->Ib', U_Eia.reshape(-1, n_c),
DELTA_ab)
self.ug.point_data.vectors = U_vector_field
self.ug.point_data.vectors.name = 'displacement'
eps_Emab = np.einsum('Eimabc,Eic->Emab', ts.B_Eimabc, U_Eia)
deps_Emab = np.zeros_like(eps_Emab)
D_Emabef, sig_Emab = mats.get_corr_pred(eps_Emab, deps_Emab, t, t,
False, False,
**ts.state_arrays)
sig_Emcd = np.einsum('...ab,ac,bd->...cd', sig_Emab, DELTA_ab,
DELTA_ab)
sig_Emcd_tensor_field = sig_Emcd.reshape(-1, 9)
self.ug.point_data.tensors = sig_Emcd_tensor_field
self.ug.point_data.tensors.name = 'stress'
fname = 'step_%008.4f' % t
home = os.path.expanduser('~')
target_file = os.path.join(home, 'simdb', 'simdata',
fname.replace('.', '_')) + '.vtu'
write_data(self.ug, target_file)
self.file_list.append(target_file)
def convert_to_vts(self, outdir='.', Radius=1., name='basin'):
from tvtk.api import tvtk, write_data
from sympy.ntheory import primefactors
lonArr = np.array([])
latArr = np.array([])
for geopolygon in self.geopolygons:
lonArr = np.append(lonArr, geopolygon.lonArr)
latArr = np.append(latArr, geopolygon.latArr)
theta = (90. - latArr) / 180. * np.pi
phi = lonArr / 180. * np.pi
x = Radius * np.sin(theta) * np.cos(phi)
y = Radius * np.sin(theta) * np.sin(phi)
z = Radius * np.cos(theta)
pts = np.empty(z.shape + (3, ), dtype=float)
pts[..., 0] = x
pts[..., 1] = y
pts[..., 2] = z
least_prime = primefactors(x.size)[0]
dims = (x.size / least_prime, least_prime, 1)
sgrid = tvtk.StructuredGrid(dimensions=dims, points=pts)
sgrid.point_data.scalars = (np.ones(x.size)).ravel(order='F')
sgrid.point_data.scalars.name = name
outfname = outdir + '/' + name + '.vts'
write_data(sgrid, outfname)
return
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 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 write_file(self, step=0):
# We will create the directory only when writing the file
if not os.path.isdir(self.directory):
os.makedirs(self.directory)
filename = "{}_{:06}".format(self.filename, step)
write_data(self.grid, os.path.join(self.directory, filename))
def save_evaluate_vtk(result, outfile, **kwds):
'''
Save a evaluation result to a VTK file.
'''
from tvtk.api import tvtk, write_data
points = result.parent_by_type('volume').array_data_by_type()['points']
filter = tvtk.AppendFilter()
pot = result.array_data_by_type()['scalar']
pd = tvtk.PolyData(points = points)
pd.point_data.scalars = pot.T
pd.point_data.scalars.name = result.name
pd.cell_data.scalars = pot.T
pd.cell_data.scalars.name = result.name
if False:
filter.add_input_data(pd)
filter.update()
ug = tvtk.UnstructuredGrid()
ug.shallow_copy(filter.get_output())
write_data(ug, outfile)
else:
write_data(pd, outfile)
return
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 main(outname=None, *infiles):
if outname is None or outname == "-":
outname = os.path.splitext(infile)[0]
jblobs = list()
jpoints = list()
for infile in infiles:
jdat = json.loads(open(infile).read())
jblobs += jdat["blobs"]
jpoints += jdat.get("points", [])
blobdata = rendertvtk.blobs(jblobs)
#w = tvtk.XMLUnstructuredGridWriter(file_name=outfile)
#w = tvtk.UnstructuredGridWriter(file_name=outfile)
#configure_input(w, ugrid)
#w.write()
ofile = outname + '-blobs.vtu'
print(ofile)
write_data(blobdata, ofile)
### see depo2tvtk.py for rendering depos from NumpyDepoSaver
if not jpoints:
print("no points to convert")
return
pointdata = rendertvtk.points(jpoints)
ofile = outname + "-points.vtp"
print(ofile)
write_data(pointdata, ofile)
def update(self):
#ts = self.sim.tstep
ts = self.tstep
U = ts.U_k
t_n1 = ts.t_n1
U_vector_fields = []
var_Encd_tensor_fields = []
for domain in ts.fe_domain:
xdomain = domain.xmodel
var_function = domain.tmodel.var_dict.get(self.var, None)
if var_function == None or xdomain.hidden:
continue
fets = xdomain.fets
DELTA_x_ab = fets.vtk_expand_operator
DELTA_f_ab = xdomain.vtk_expand_operator
U_Eia = U[xdomain.o_Eia]
_, _, n_a = U_Eia.shape
U_vector_fields.append(
np.einsum('Ia,ab->Ib', U_Eia.reshape(-1, n_a), DELTA_x_ab))
eps_Enab = xdomain.map_U_to_field(U)
# copy the state variable as the operator
var_Enab = var_function(eps_Enab, t_n1, **domain.state_k)
var_Encd = np.einsum('...ab,ac,bd->...cd', var_Enab, DELTA_f_ab,
DELTA_f_ab)
var_Encd_tensor_fields.append(var_Encd.reshape(-1, 9))
self.ug.point_data.vectors = np.vstack(U_vector_fields)
self.ug.point_data.vectors.name = 'displacement'
self.ug.point_data.tensors = np.vstack(var_Encd_tensor_fields)
self.ug.point_data.tensors.name = self.var
fname = '%s_step_%08.4f' % (self.var, t_n1)
target_file = os.path.join(self.dir, fname.replace(
'.', '_')) + '.' + self.extension
write_data(self.ug, target_file)
self.add_file(target_file)
def vf3d_vtu(field, name):
"""
Function that wtrites a .vtu file
---Inputs---
field - Vector field which will be added to the vtk file numpy.array([x,y,z,u,v,w])
name - Name of the .vtu field
---
C.Losada de la Lastra 2015
"""
[X, Y, Z, U, V, W] = field #3d velocity field
#achieve the correct format
Pnts = F3d_2_vtkFromat(N.array([X, Y, Z]))
velF = F3d_2_vtkFromat(N.array([U, V, W]))
#name the vtu file
if name == None:
vtu = 'vf3VTU.vtu'
else:
vtu = name + '.vtu'
#Generate and write the .vtu file
Ugrid = tvtk.UnstructuredGrid()
Ugrid.points = Pnts
Ugrid.point_data.vectors = velF
Ugrid.point_data.vectors.name = 'velocity'
write_data(Ugrid, vtu)
return vtu
def save_evaluate_vtk(result, outfile, **kwds):
'''
Save a evaluation result to a VTK file.
'''
from tvtk.api import tvtk, write_data
points = result.parent_by_type('volume').array_data_by_type()['points']
filter = tvtk.AppendFilter()
pot = result.array_data_by_type()['scalar']
pd = tvtk.PolyData(points=points)
pd.point_data.scalars = pot.T
pd.point_data.scalars.name = result.name
pd.cell_data.scalars = pot.T
pd.cell_data.scalars.name = result.name
if False:
filter.add_input_data(pd)
filter.update()
ug = tvtk.UnstructuredGrid()
ug.shallow_copy(filter.get_output())
write_data(ug, outfile)
else:
write_data(pd, outfile)
return
def save_waveforms_vtk(result, outfile, **kwds):
'''
Save a waveforms result to a VTK file.
'''
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_type()
paths = arrs['path']
pscalar = arrs['pscalar']
# flatten
points = list()
pathids = list()
times = list()
scalars = list()
npaths, nsteps, four = paths.shape
for ipath in range(npaths):
for istep in range(nsteps):
points.append(paths[ipath][istep][1:])
pathids.append(ipath)
times.append(paths[ipath][istep][0])
scalars.append(pscalar[ipath][istep])
ug = tvtk.UnstructuredGrid()
ug.points = points
ug.point_data.scalars = scalars
ug.point_data.scalars.name = 'current' # fixme: should get from result
ug.point_data.add_array(times)
ug.point_data.get_array(1).name = 'time'
ug.point_data.add_array(pathids)
ug.point_data.get_array(2).name = 'pathid'
write_data(ug, outfile)
return
def save_current_vtk(result, outfile, **kwds):
'''
Save current assuming no structure between starting points
'''
from tvtk.api import tvtk, write_data
cres = result
dres = cres.parent_by_type('drift') # drift
values = numpy.hstack([a.data for a in cres.arrays if a.type == 'pscalar'])
points4 = numpy.vstack([a.data for a in dres.arrays if a.type == 'path'])
assert len(values) == len(points4)
points = points4[:, :3]
npoints = len(points)
print 'shapes: %s %s' % (str(values.shape), str(points.shape))
ug = tvtk.UnstructuredGrid()
point_type = tvtk.Vertex().cell_type
cell_types = numpy.array([point_type] * npoints)
cell_array = tvtk.CellArray()
cells = numpy.array([npoints] + range(npoints))
cell_array.set_cells(point_type, cells)
ug.set_cells(1, cell_array)
ug.points = points
ug.point_data.scalars = values
ug.point_data.scalars.name = 'current'
write_data(ug, outfile)
def save_waveforms_vtk(result, outfile, **kwds):
'''
Save a waveforms result to a VTK file.
'''
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_type()
paths = arrs['path']
pscalar = arrs['pscalar']
# flatten
points = list()
pathids = list()
times = list()
scalars = list()
npaths, nsteps, four = paths.shape
for ipath in range(npaths):
for istep in range(nsteps):
points.append(paths[ipath][istep][1:])
pathids.append(ipath)
times.append(paths[ipath][istep][0])
scalars.append(pscalar[ipath][istep])
ug = tvtk.UnstructuredGrid()
ug.points = points
ug.point_data.scalars = scalars
ug.point_data.scalars.name = 'current' # fixme: should get from result
ug.point_data.add_array(times)
ug.point_data.get_array(1).name = 'time'
ug.point_data.add_array(pathids)
ug.point_data.get_array(2).name = 'pathid'
write_data(ug, outfile)
return
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 save_drift_vtk(result, outname, **kwds):
'''
Save a drift result into a VTK file.
'''
outname = osp.splitext(outname)[0]
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_name()
for thing in ['potential', 'gradient', 'velocity']:
points = arrs[thing + '_points']
values = arrs[thing]
npoints = len(points)
ug = tvtk.UnstructuredGrid()
point_type = tvtk.Vertex().cell_type
cell_types = numpy.array([point_type] * npoints)
cell_array = tvtk.CellArray()
cells = numpy.array([npoints] + range(npoints))
cell_array.set_cells(point_type, cells)
ug.set_cells(1, cell_array)
ug.points = points
ug.point_data.scalars = values
ug.point_data.scalars.name = thing
fname = '%s-%s.vtk' % (outname, thing)
print 'writing %s' % fname
write_data(ug, fname)
def do_save(grid, arrays):
from tvtk.api import tvtk
from tvtk.api import write_data
pd = tvtk.PolyData()
pd.points = grid.leaf_view.vertices.T
pd.polys = grid.leaf_view.elements
pd.point_data.scalars = grid.leaf_view.domain_indices
pd.point_data.scalars.name = "domains"
write_data(pd, "test_kitchen_sink_grid.vtk")
abn = {a.type: a.data for a in arrays}
mgrid = abn["mgrid"]
potential = abn["gscalar"]
gradient = abn["gvector"]
print dimensions, potential.shape
print 'spacing:', spacing
print 'origin:', origin
print 'dimensions:', dimensions
sp = tvtk.StructuredPoints(spacing=spacing,
origin=origin,
dimensions=dimensions)
sp.point_data.scalars = potential.ravel(order='F')
sp.point_data.scalars.name = "potential"
sp.point_data.vectors = gradient.ravel(order='F')
sp.point_data.vectors.name = "gradient"
write_data(sp, "test_kitchen_sink_potential.vtk")
numpy.savez_compressed("test_kitchen_sink.npz", **abn)
def do_save(grid, arrays):
from tvtk.api import tvtk
from tvtk.api import write_data
pd = tvtk.PolyData()
pd.points = grid.leaf_view.vertices.T
pd.polys = grid.leaf_view.elements
pd.point_data.scalars = grid.leaf_view.domain_indices
pd.point_data.scalars.name = "domains"
write_data(pd, "test_kitchen_sink_grid.vtk")
abn = {a.type:a.data for a in arrays}
mgrid = abn["mgrid"]
potential = abn["gscalar"]
gradient = abn["gvector"]
print dimensions, potential.shape
print 'spacing:',spacing
print 'origin:',origin
print 'dimensions:',dimensions
sp = tvtk.StructuredPoints(spacing=spacing, origin=origin, dimensions=dimensions)
sp.point_data.scalars = potential.ravel(order='F')
sp.point_data.scalars.name = "potential"
sp.point_data.vectors = gradient.ravel(order='F')
sp.point_data.vectors.name = "gradient"
write_data(sp, "test_kitchen_sink_potential.vtk")
numpy.savez_compressed("test_kitchen_sink.npz", **abn)
def save_drift_vtk(result, outname, **kwds):
'''
Save a drift result into a VTK file.
'''
outname = osp.splitext(outname)[0]
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_name()
for thing in ['potential','gradient','velocity']:
points = arrs[thing+'_points']
values = arrs[thing]
npoints = len(points)
ug = tvtk.UnstructuredGrid()
point_type = tvtk.Vertex().cell_type
cell_types = numpy.array([point_type]*npoints)
cell_array = tvtk.CellArray()
cells = numpy.array([npoints]+range(npoints))
cell_array.set_cells(point_type, cells)
ug.set_cells(1, cell_array)
ug.points = points
ug.point_data.scalars = values
ug.point_data.scalars.name = thing
fname = '%s-%s.vtk' % (outname, thing)
print 'writing %s' % fname
write_data(ug, fname)
def save_current_vtk(result, outfile, **kwds):
'''
Save current assuming no structure between starting points
'''
from tvtk.api import tvtk, write_data
cres = result
dres = cres.parent_by_type('drift') # drift
values = numpy.hstack([a.data for a in cres.arrays if a.type == 'pscalar'])
points4 = numpy.vstack([a.data for a in dres.arrays if a.type == 'path'])
assert len(values) == len(points4)
points = points4[:,:3]
npoints = len(points)
print 'shapes: %s %s' % (str(values.shape), str(points.shape))
ug = tvtk.UnstructuredGrid()
point_type = tvtk.Vertex().cell_type
cell_types = numpy.array([point_type]*npoints)
cell_array = tvtk.CellArray()
cells = numpy.array([npoints]+range(npoints))
cell_array.set_cells(point_type, cells)
ug.set_cells(1, cell_array)
ug.points = points
ug.point_data.scalars = values
ug.point_data.scalars.name = 'current'
write_data(ug, outfile)
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 vf3d_vtu(field,name):
"""
Function that wtrites a .vtu file
---Inputs---
field - Vector field which will be added to the vtk file numpy.array([x,y,z,u,v,w])
name - Name of the .vtu field
---
C.Losada de la Lastra 2015
"""
[X,Y,Z,U,V,W] = field #3d velocity field
#achieve the correct format
Pnts = F3d_2_vtkFromat(N.array([X,Y,Z]))
velF = F3d_2_vtkFromat(N.array([U,V,W]))
#name the vtu file
if name == None:
vtu = 'vf3VTU.vtu'
else:
vtu = name + '.vtu'
#Generate and write the .vtu file
Ugrid = tvtk.UnstructuredGrid()
Ugrid.points = Pnts
Ugrid.point_data.vectors = velF
Ugrid.point_data.vectors.name = 'velocity'
write_data(Ugrid, vtu)
return vtu
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 write_species_vtk(self,
species=None,
iteration=0,
format='binary',
scalars=['ux', 'uy', 'uz', 'w'],
select=None,
zmin_fixed=None):
"""
Convert the given list of species from the openPMD format to
a VTK container, and write it to the disk.
Parameters
----------
species: list or None
List of species names to be converted. If None, it
converts all available species provided by OpenPMDTimeSeries
scalars: list of strings
list of values associated with each paricle to be included.
ex. : 'charge', 'id', 'mass', 'x', 'y', 'z', 'ux', 'uy', 'uz', 'w'
iteration: int
iteration number to treat (default 0)
select: dict
dictonary to impoer selection on the particles,
as it is defined in opnePMD_viewer
format: str
format for the VTK file, either 'ascii' or 'binary'
zmin_fixed: float or None
When treating the simulation data for the animation, in
some cases (e.g. with moving window) it is useful to
fix the origin of the visualization domain. If float number
is given it will be use as z-origin of the visualization domain
"""
# Check available fields if comps is not defined
if species is None:
species = self.ts.avail_species
# register constants
self.iteration = iteration
self.zmin_fixed = zmin_fixed
self.select = select
self.scalars = scalars
# Make a numer string for the file to write
istr = str(self.iteration)
while len(istr) < 7:
istr = '0' + istr
name_base = self.path + 'vtk_specie_{:}_{:}'
# Convert and save all the species
for specie in species:
self._convert_species(specie)
write_data(self.pts_vtk, name_base)
def save_output(self, fname):
"""Save our output (by default the first of our outputs) to the
specified filename as a VTK file. Both old style and new style
XML files are supported.
"""
if len(self.outputs) > 0:
write_data(self.get_output_dataset(), fname)
else:
error('Object has no outputs to save!')
def save_output(self, fname):
"""Save our output (by default the first of our outputs) to the
specified filename as a VTK file. Both old style and new style
XML files are supported.
"""
if len(self.outputs) > 0:
write_data(self.get_output_dataset(), fname)
else:
error('Object has no outputs to save!')
def save_volume_vtk(result, outfile, **kwds):
'''
Save a volume result to a VTK file.
'''
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_name()
pd = tvtk.PolyData()
pd.points = arrs['volume']
write_data(pd, outfile)
return
def do_one(gr, n=0):
if 0 == gr.number_of_nodes():
click.echo("no verticies in %s" % cluster_tap_file)
return
dat = converter.clusters2blobs(gr)
fname = paraview_file
if '%' in paraview_file:
fname = paraview_file % n
write_data(dat, fname)
click.echo(fname)
def save_volume_vtk(result, outfile, **kwds):
'''
Save a volume result to a VTK file.
'''
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_name()
pd = tvtk.PolyData()
pd.points = arrs['volume']
write_data(pd, outfile)
return
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 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 test_write_data_xml(self):
"XML file writing with specified extension"
datasets = self.datasets
for d in datasets:
fh, fname = tempfile.mkstemp('.xml')
os.close(fh)
os.remove(fname)
self.assertEqual(os.path.exists(fname), False)
write_data(d, fname)
self.assertEqual(os.path.exists(fname), True)
os.remove(fname)
def test_write_data_xml(self):
"XML file writing with specified extension"
datasets = self.datasets
for d in datasets:
fh, fname = tempfile.mkstemp('.xml')
os.close(fh)
os.remove(fname)
self.assertEqual(os.path.exists(fname), False)
write_data(d, fname)
self.assertEqual(os.path.exists(fname), True)
os.remove(fname)
def contour(path, savepath, mrc=None):
if mrc is None:
# path = os.path.join(settings.MEDIA_ROOT, path) #comment this and line 15 and correct line 17 if executing only locally. This is configuration for the server.
mrc = mrcfile.open(path)
# print(type(mrc.data))
mlab.options.offscreen = True # without this line, it will get stuck on next line
obj = contour3d(mrc.data, contours=4, figure=None)
mlab.close(all=True)
vtkout = obj.contour.contour_filter.output
# write_data(vtkout, os.path.join(settings.MEDIA_ROOT, savepath))
write_data(vtkout, savepath)
# obj.module_manager.source.save_output(savepath)
return obj
def do_one(gr, n=0):
fname, ext = os.path.splitext(paraview_file)
if '%' in fname:
fname = fname % n
if 0 == gr.number_of_nodes():
click.echo("no verticies in %s" % cluster_tap_file)
return
alldat = converter.clusters2views(gr)
for wpid, dat in alldat.items():
pname = f'{fname}-plane{wpid}{ext}'
write_data(dat, pname)
click.echo(pname)
def paraview_blobs(ctx, depo_npz_file, paraview_file):
'''
Convert an NPZ file to a ParaView .vtu file of depos
'''
from . import converter
from tvtk.api import write_data
import numpy
fp = numpy.load(open(depo_npz_file))
dat = fp['depo_data_0']
ugrid = converter.depos2pts(dat)
write_data(ugrid, paraview_file)
click.echo(paraview_file)
return
def test_write_data_xml_kwargs(self):
"XML file writing with extra keyword arguments"
datasets = self.datasets
exts = self.exts
for d, ext in zip(datasets, exts):
fh, fname = tempfile.mkstemp(ext)
fbase = os.path.splitext(fname)[0]
os.close(fh)
os.remove(fname)
# Test if passing extra keyword args is supported.
write_data(d, fbase, compressor=None, data_mode='ascii')
self.assertEqual(os.path.exists(fname), True)
os.remove(fname)
def test_write_data_xml_kwargs(self):
"XML file writing with extra keyword arguments"
datasets = self.datasets
exts = self.exts
for d, ext in zip(datasets, exts):
fh, fname = tempfile.mkstemp(ext)
fbase = os.path.splitext(fname)[0]
os.close(fh)
os.remove(fname)
# Test if passing extra keyword args is supported.
write_data(d, fbase, compressor=None, data_mode='ascii')
self.assertEqual(os.path.exists(fname), True)
os.remove(fname)
def convert_to_vts(self, outdir, component, iter0=None, iterf=None, diter=None, Radius=0.98, verbose=True):
"""
Plot depth slices of field component at given depth ranging between "valmin" and "valmax"
================================================================================================
Input parameters:
outdir - output directory
component - component for plotting
The currently available "components" are:
Material parameters: A, B, C, mu, lambda, rhoinv, vp, vsh, vsv, rho
Velocity field snapshots: vx, vy, vz
Sensitivity kernels: Q_mu, Q_kappa, alpha_mu, alpha_kappa
depth - depth for plot (km)
iter0, iterf - start/end iteration index
diter - iteration interval
Radius - radius for output sphere
=================================================================================================
"""
if not os.path.isdir(outdir): os.makedirs(outdir)
group=self[component]
from tvtk.api import tvtk, write_data
try: iterArr=np.arange(iter0 ,iterf+diter, diter, dtype=int)
except: iterArr = group.keys()
least_prime=None
for iteration in iterArr:
subgroup=group[str(iteration)]
if len(subgroup.keys())==0: continue
if verbose: print 'Output vts file for iteration =',iteration
theta=np.array([]); phi=np.array([]); r=np.array([]); field = np.array([])
for key in subgroup.keys():
subdset = subgroup[key]
field = np.append(field, (subdset[...]))
theta1 = subdset.attrs['theta']
phi1 = subdset.attrs['phi']
theta1, phi1 = np.meshgrid(theta1, phi1, indexing='ij')
theta = np.append(theta, theta1)
phi = np.append(phi, phi1)
x = Radius * np.sin(theta) * np.cos(phi)
y = Radius * np.sin(theta) * np.sin(phi)
z = Radius * np.cos(theta)
if least_prime==None: least_prime=primefactors(field.size)[0]
dims = (field.size/least_prime, least_prime, 1)
pts = np.empty(z.shape + (3,), dtype=float)
pts[..., 0] = x; pts[..., 1] = y; pts[..., 2] = z
sgrid = tvtk.StructuredGrid(dimensions=dims, points=pts)
sgrid.point_data.scalars = (field).ravel(order='F')
sgrid.point_data.scalars.name = component
outfname=outdir+'/'+component+'_'+str(iteration)+'.vts'
write_data(sgrid, outfname)
return
def _dump_arrays(self, filename):
from tvtk.api import tvtk
n = self.numPoints
cells = np.arange(n)
cells.shape = (n, 1)
cell_type = tvtk.Vertex().cell_type
ug = tvtk.UnstructuredGrid(points=self.points.transpose())
ug.set_cells(cell_type, cells)
from mayavi.core.dataset_manager import DatasetManager
dsm = DatasetManager(dataset=ug)
for name, field in self.data:
dsm.add_array(field.transpose(), name)
dsm.activate(name)
from tvtk.api import write_data
write_data(ug, filename)
def test_write_data_vtk(self):
"Old-style VTK file writing with specified extension"
datasets = self.datasets
for d in datasets:
fh, fname = tempfile.mkstemp('.vtk')
os.close(fh)
os.remove(fname)
self.assertEqual(os.path.exists(fname), False)
write_data(d, fname)
self.assertEqual(os.path.exists(fname), True)
r = tvtk.DataSetReader(file_name=fname)
r.update()
self.assertEqual(isinstance(r.output, d.__class__), True)
os.remove(fname)
def test_write_data_xml_noext(self):
"XML file writing without extensions"
# Check if write_data writes out XML files with the correct
# extension when none is specified.
datasets = self.datasets
exts = self.exts
for d, ext in zip(datasets, exts):
fh, fname = tempfile.mkstemp(ext)
fbase = os.path.splitext(fname)[0]
os.close(fh)
os.remove(fname)
write_data(d, fbase)
self.assertEqual(os.path.exists(fname), True)
os.remove(fname)
def _save_meshlike_points_vtk(result, outfile, **kwds):
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_type()
points = arrs['points']
triangles = arrs['indices']
pd = tvtk.PolyData()
pd.points = points
pd.polys = triangles
#pd.cell_data.scalars = domains
#pd.cell_data.scalars.name = "domains"
write_data(pd, outfile)
return
def save_points_vtk(result, outfile, **kwds):
'''
Save a points result to a VTK file.
'''
from tvtk.api import tvtk, write_data
if "indices" in result.array_data_by_type():
return _save_meshlike_points_vtk(result, outfile, **kwds)
for typ, nam, arr in result.triplets():
print typ,nam,arr.shape
dim = arr.shape[:-1]
points = arr.reshape(numpy.product(dim), arr.shape[-1])
pd = tvtk.StructuredGrid(dimensions = (1, dim[0], dim[1]),
points=points)
n,e = osp.splitext(outfile)
fname = n + "-" + nam + e
print "writing %s" % fname
write_data(pd, fname)
def save_surface_vtk(result, outfile, **kwds):
'''
Save a surface result to a VTK file.
'''
from tvtk.api import tvtk, write_data
arrs = result.array_data_by_name()
points = arrs['vertices']
triangles = arrs['elements']
domains = arrs['domains']
pd = tvtk.PolyData()
pd.points = points
pd.polys = triangles
pd.cell_data.scalars = domains
pd.cell_data.scalars.name = "domains"
write_data(pd, outfile)
return
def save_mesh_vtk(result, outfile, **kwds):
'''
Save a mesh result to a VTK file.
'''
from tvtk.api import tvtk
from tvtk.api import write_data
arrs = result.array_data_by_type()
points = arrs['points']
triangles = arrs['triangles']
domains = arrs['elscalar']
pd = tvtk.PolyData()
pd.points = points
pd.polys = triangles
pd.cell_data.scalars = domains
pd.cell_data.scalars.name = "domains"
write_data(pd, outfile)
return
def convert_to_vts(self, outdir='.', Radius=1., name='basin'):
from tvtk.api import tvtk, write_data
from sympy.ntheory import primefactors
lonArr=np.array([]); latArr=np.array([])
for geopolygon in self.geopolygons:
lonArr=np.append(lonArr, geopolygon.lonArr)
latArr=np.append(latArr, geopolygon.latArr)
theta=(90.-latArr)/180.*np.pi; phi=lonArr/180.*np.pi
x = Radius * np.sin(theta) * np.cos(phi)
y = Radius * np.sin(theta) * np.sin(phi)
z = Radius * np.cos(theta)
pts = np.empty(z.shape + (3,), dtype=float)
pts[..., 0] = x; pts[..., 1] = y; pts[..., 2] = z
least_prime=primefactors(x.size)[0]
dims = (x.size/least_prime, least_prime, 1)
sgrid = tvtk.StructuredGrid(dimensions=dims, points=pts)
sgrid.point_data.scalars = (np.ones(x.size)).ravel(order='F')
sgrid.point_data.scalars.name = name
outfname=outdir+'/'+name+'.vts'
write_data(sgrid, outfname)
return
def save(self, i):
self.mask_nonfluid_nodes()
os.environ['ETS_TOOLKIT'] = 'null'
from tvtk.api import tvtk
idata = tvtk.ImageData(spacing=(1, 1, 1), origin=(0, 0, 0))
first = True
sample_field = None
for name, field in self._scalar_fields.items():
if first:
idata.point_data.scalars = field.flatten()
idata.point_data.scalars.name = name
first = False
sample_field = field
else:
t = idata.point_data.add_array(field.flatten())
idata.point_data.get_array(t).name = name
# idata.update()
dim = len(sample_field.shape)
for name, field in self._vector_fields.items():
if dim == 3:
tmp = idata.point_data.add_array(np.c_[field[0].flatten(),
field[1].flatten(), field[2].flatten()])
else:
tmp = idata.point_data.add_array(np.c_[field[0].flatten(),
field[1].flatten(),
np.zeros_like(field[0].flatten())])
idata.point_data.get_array(tmp).name = name
if dim == 3:
idata.dimensions = list(reversed(sample_field.shape))
else:
idata.dimensions = list(reversed(sample_field.shape)) + [1]
fname = filename(self.basename, self.digits, self.subdomain_id, i, suffix='.vti')
from tvtk.api import write_data
write_data(idata, fname)
def save_wires_vtk(result, outfile, **kwds):
'''
Save wires.
'''
from tvtk.api import tvtk, write_data
points = list()
lines = list()
plane_numbers = list()
domains = list()
iplane=0
for typ,nam,arr in result.triplets():
if typ != 'rays':
continue
mp = result.params[iplane]
params = mp['params']
domain_offset = params['domain_offset']
iplane += 1
print iplane, domain_offset, typ, nam, arr.shape
for iwire,(t,h) in enumerate(arr):
plane_numbers.append(iplane)
ti = len(points)
points.append(t)
hi = len(points)
points.append(h)
lines.append((ti,hi))
domains.append(domain_offset + iwire)
point_type = tvtk.Line().cell_type
pd = tvtk.PolyData(points=numpy.asarray(points), lines=numpy.asarray(lines))
pd.cell_data.add_array(numpy.asarray(plane_numbers))
pd.cell_data.get_array(0).name = 'plane'
pd.cell_data.add_array(numpy.asarray(domains))
pd.cell_data.get_array(1).name = 'domain'
write_data(pd, outfile)
def save_oldboundary_vtk(result, outfile, **kwds):
from tvtk.api import tvtk
from tvtk.api import write_data
meshres = result.parents[0]
arrs = meshres.array_data_by_type()
points = arrs['points']
triangles = arrs['triangles']
pd = tvtk.PolyData()
pd.points = points
pd.polys = triangles
npoint = ncell = 0
for arr in result.arrays:
if arr.type == 'ptscalar':
pd.point_data.add_array(arr.data)
pd.point_data.get_array(npoint).name = arr.name
print "Adding <%s> %s [%d] as point data #%d" % (arr.type, arr.name, len(arr.data), npoint)
npoint += 1
#pd.point_data.scalars = arr.data
#pd.point_data.scalars.name = arr.name
continue
if arr.type == 'elscalar':
pd.cell_data.add_array(arr.data)
pd.cell_data.get_array(ncell).name = arr.name
print "Adding <%s> %s [%d] as cell data #%d" % (arr.type, arr.name, len(arr.data), npoint)
ncell += 1
#pd.cell_data.scalars = arr.data
#pd.cell_data.scalars.name = arr.name
continue
print 'Warning: unknown array type: %s %s %s' % (arr.type, arr.name, arr.data.shape)
write_data(pd, outfile)
return
def save_boundary_vtk(result, outfile, **kwds):
from tvtk.api import tvtk, write_data
sres = result.parents[0]
sarrs = sres.array_data_by_name()
points = sarrs['vertices']
triangles = sarrs['elements']
domains = sarrs['domains']
barrs = result.array_data_by_name()
pd = tvtk.PolyData()
pd.points = points
pd.polys = triangles
pd.cell_data.add_array(domains)
pd.cell_data.get_array(0).name = 'domains'
for count, name in enumerate(['dirichlet', 'neumann']):
pd.cell_data.add_array(barrs[name])
pd.cell_data.get_array(count + 1).name = name
write_data(pd, outfile)
return
from scipy import io
import numpy as np
from evtk.hl import imageToVTK
from evtk.hl import gridToVTK
test = {}
io.loadmat('iCPC3D04a_v3d_x1_uint8.mat',mdict=test)
vox3dnp = np.array(test['vox3d'])
imageToVTK('./test', origin=(0.0,0.0,0.0), spacing = (sp,sp,sp), cellData = {'grayscale': np.ascontiguousarray(vox3dnp)})
sp = test['voxsize'][0][0]
w, h, d = vox3dnp.shape
x = np.linspace(0.0, sp*(w), w+1, dtype=np.float32)
y = np.linspace(0.0, sp*(h), h+1, dtype=np.float32)
z = np.linspace(0.0, sp*(d), d+1, dtype=np.float32)
from tvtk.api import tvtk, write_data
grid = tvtk.ImageData(spacing=(sp, sp, sp), origin=(0.0, 0.0, 0.0), dimensions=vox3dnp.shape)
grid.point_data.scalars = np.ravel(vox3dnp, order='F')
grid.point_data.scalars.name = 'grayscale'
# Writes legacy ".vtk" format if filename ends with "vtk", otherwise
# this will write data using the newer xml-based format.
write_data(grid, 'test3.vtk')
def WriteVtkFile(self,job,step=0):
write_data( self.ugdata, job+str(step).zfill(4)+'.vtu' )
def WriteVtkFile(self,filename):
write_data( self.ugdata, filename )
vals = np.empty(nPointsX * nPointsY, dtype=complex)
np.place(vals, outside, valsExt.ravel())
np.place(vals, inside, valsInt.ravel())
# Display the field plot
from bempp import visualization2 as vis
tvtkU = vis.tvtkStructuredGridData(
points, vals, (nPointsX, nPointsY))
tvtkGrid = vis.tvtkGrid(grid)
vis.plotScalarData(tvtkGrid, None, tvtkU)
# Export the results into a VTK file
from tvtk.api import write_data
write_data(tvtkU, "u.vts")
# PART 6: Evaluate the far-field pattern of the scattered field ################
# Create the necessary potential operators
slFfPot = lib.createHelmholtz3dFarFieldSingleLayerPotentialOperator(context, kExt)
dlFfPot = lib.createHelmholtz3dFarFieldDoubleLayerPotentialOperator(context, kExt)
# Define a set of points on the unit sphere and evaluate the potentials
theta = np.linspace(0, 2*np.pi, 361)
points = np.vstack([np.cos(theta), np.sin(theta), 0. * theta])
farFieldPattern = (- slFfPot.evaluateAtPoints(uScDeriv, points, evalOptions)
+ dlFfPot.evaluateAtPoints(uSc, points, evalOptions))
def _write_vtk_snapshot(self, mesh, directory, _fname):
fname = path.join(directory, _fname)
write_data(mesh, fname)
def save_current_band_vtk(result, outfile, **kwds):
'''
Save a current result into a VTK file, assuming a 2D band of start points
'''
# Current result has N_path pscalar arrays (N_i,), one per path and holding current for each step
# Drift result i has path points array (N_i,4), same name as current
# Starts result has (A,B,3) array of starting points. A*B=N_path
# goal: export in A x B x max(N_i) array of scalar currents
# goal2: export current_points and current pscalar
from tvtk.api import tvtk, write_data
cres = result
dres = cres.parent_by_type('drift') # drift
sres = dres.parent_by_type('points') # starts
carrs = [a.data for a in cres.arrays if a.type == 'pscalar']
maxticks = max([a.shape[0] for a in carrs])
print '%d current arrays, maxticks=%d' % (len(carrs), maxticks)
start_points = sres.arrays[0].data
print 'shape of start points: %s' % str(start_points.shape)
nlong, nlat = start_points.shape[:2]
longdiff = start_points[0,0] - start_points[1,0]
dlong = math.sqrt(numpy.dot(longdiff, longdiff))
latdiff = start_points[0,0] - start_points[0,1]
dlat = math.sqrt(numpy.dot(latdiff, latdiff))
#darrs = [a.data for a in dres.arrays if a.type == 'path']
#p1 = darrs[0]
#dt = p1[1,3] - p1[0,3]
dt = 0.1
spacing = (dlong, dlat, dt)
print "spacing %s" % str(spacing)
current = numpy.zeros((nlong, nlat, maxticks))
print "current %s" % str(current.shape)
avgcurrent = numpy.zeros((nlat, maxticks))
indices = numpy.array(range(len(carrs))).reshape((nlong, nlat))
for ilong in range(nlong):
for ilat in range(nlat): # fastest index, see larf.points.wires.aligned_grid
ind = indices[ilong,ilat]
cur = carrs[ind]
ncur = len(cur)
print '%d: %d %d %d' % (ind, ilong, ilat, ncur)
current[ilong,ilat,:ncur] = cur
avgcurrent[ilat,:ncur] += cur
# hijack this function to also dump out an average.
avgcurrent /= nlong
npzfile = osp.splitext(outfile)[0] + '.npz'
numpy.savez_compressed(npzfile, current=avgcurrent)
dat = tvtk.ImageData(spacing=spacing, dimensions=current.shape)
dat.point_data.scalars = current.ravel(order='F')
dat.point_data.scalars.name = 'current'
write_data(dat, outfile)
