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