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 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_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_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 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 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 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)