def export_vtk_cut(img, filename="default.vtk", dictionary=None, verbose=False): """ paramètres : img : SpatialImage ou SpatialImageAnalysis filename : le nom de la sortie dictionary : dictionnaire cells->scalar lut : disponibles dans colormaps verbose : pour afficher ou non les progressions ATTENTION, SUR CERTAINES MACHINES LE FICHIER VTK A DES VIRGULES POUR DEFINIR LES DOUBLE, ALORS QUE LES SOFTS ONT BESOIN DE POINTS """ #management of file format if isinstance(img, SpatialImageAnalysis3D): p = img2polydata_simple(img.image, dictionnaire=dictionary, verbose=verbose) elif isinstance(img, SpatialImage): p = img2polydata_simple(img, dictionnaire=dictionary, verbose=verbose) else: warnings.warn("for now this file format is not managed by export_vtk") return p.update() w = tvtk.PolyDataWriter() w.input = p.output w.file_name = filename w.write()
def test_trans_distances(): tempdir = mkdtemp() in_surf = example_data('surf01.vtk') warped_surf = os.path.join(tempdir, 'warped.vtk') curdir = os.getcwd() os.chdir(tempdir) inc = np.array([0.7, 0.3, -0.2]) r1 = tvtk.PolyDataReader(file_name=in_surf) vtk1 = r1.output r1.update() vtk1.points = np.array(vtk1.points) + inc writer = tvtk.PolyDataWriter(file_name=warped_surf) writer.set_input_data(vtk1) writer.write() dist = m.ComputeMeshWarp() dist.inputs.surface1 = in_surf dist.inputs.surface2 = warped_surf dist.inputs.out_file = os.path.join(tempdir, 'distance.npy') res = dist.run() yield assert_almost_equal, res.outputs.distance, np.linalg.norm(inc), 4 dist.inputs.weighting = 'area' res = dist.run() yield assert_almost_equal, res.outputs.distance, np.linalg.norm(inc), 4 os.chdir(curdir) rmtree(tempdir)
def _dataset_to_string(cls, dataset): """ Convert the dataset to a vtk filedata string. """ writer = tvtk.PolyDataWriter(input=dataset, write_to_output_string=True) writer.write() return writer.output_string
def to_vtk(self, prefix, **kwargs): """saves mesh as prefix_mesh.vtk""" pd = self.to_polydata(**kwargs) pdw = tvtk.PolyDataWriter(input=pd) pdw.file_name = "%s_mesh.vtk" % prefix pdw.write() logging.debug("written mesh to %s, polydata %s", pdw.file_name, kwargs.keys()) return pd
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 _run_interface(self, runtime): import nibabel as nb import numpy as np from scipy import ndimage try: from tvtk.api import tvtk except ImportError: raise ImportError('Interface requires tvtk') r = tvtk.PolyDataReader(file_name=self.inputs.points) r.update() mesh = r.output points = np.array(mesh.points) warp_dims = nb.funcs.four_to_three(nb.load(self.inputs.warp)) affine = warp_dims[0].affine voxsize = warp_dims[0].header.get_zooms() vox2ras = affine[0:3, 0:3] ras2vox = np.linalg.inv(vox2ras) origin = affine[0:3, 3] voxpoints = np.array([np.dot(ras2vox, (p - origin)) for p in points]) warps = [] for axis in warp_dims: wdata = axis.get_data() if np.any(wdata != 0): warp = ndimage.map_coordinates(wdata, voxpoints.transpose()) else: warp = np.zeros((points.shape[0], )) warps.append(warp) disps = np.squeeze(np.dstack(warps)) newpoints = [p + d for p, d in zip(points, disps)] mesh.points = newpoints w = tvtk.PolyDataWriter() if self._vtk_major <= 5: w.input = mesh else: w.set_input_data_object(mesh) w.file_name = self._gen_fname(self.inputs.points, suffix='warped', ext='.vtk') w.write() return runtime
def export_vtk(img, filename="default", list_remove=[], dictionary=None, verbose=False): """ paramètres : img : SpatialImage ou SpatialImageAnalysis filename : le nom de la sortie list_remove : une liste des cellules à enlever lors de l'affichage dictionary : dictionnaire cells->scalar lut : disponibles dans colormaps verbose : pour afficher ou non les progressions ATTENTION, SUR CERTAINES MACHINES LE FICHIER VTK A DES VIRGULES POUR DEFINIR LES DOUBLE, ALORS QUE LES SOFTS ONT BESOIN DE POINTS """ #management of file format if isinstance(img, SpatialImageAnalysis3D): p, p2 = img2polydata_complexe(img.image, list_remove=list_remove, sc=dictionary, verbose=verbose) elif isinstance(img, SpatialImage): p, p2 = img2polydata_complexe(img, list_remove=list_remove, sc=dictionary, verbose=verbose) else: warnings.warn("for now this file format is not managed by export_vtk") return p.update() p2.update() w = tvtk.PolyDataWriter() w.input = p.output #on enlève l'extension de filename si il y en a une filename = filename.split(".")[0] w.file_name = filename + "_1.vtk" w.write() w.input = p2.output w.file_name = filename + "_2.vtk" w.write()
def main(): xo = yo = zo = 0.0 while True: a, b, c = state.uniform(size=3) xo = bounds[0] + (bounds[1] - bounds[0]) * a yo = bounds[2] + (bounds[3] - bounds[2]) * b zo = bounds[4] + (bounds[5] - bounds[4]) * c r = pow(250 - xo, 2) + pow(250 - yo, 2) print "coordinate: {},{},{}, {}".format(xo, yo, zo, r) # is_inside_surface ==1 when point is INSIDE enclosed surface if r < rad_om2 and not enclosed.is_inside_surface(xo, yo, zo): break idlist = tvtk.IdList() points = tvtk.Points() for pid in range(100001): while True: xr, yr, zr = eps * (state.uniform(size=3) - 0.5) r = pow(250 - (xo + xr), 2) + pow(250 - (yo + yr), 2) if (r < rad_om2 and not enclosed.is_inside_surface(xo+xr, yo+yr, zo+zr)): break (xo, yo, zo) = (xo + xr, yo + yr, zo + zr) idlist.insert_next_id(pid) points.insert_next_point((xo, yo, zo)) points.update_traits() # write out path trace to vtk every 5000 timesteps if pid % 5000 == 0: _array = tvtk.CellArray() rand_walk = tvtk.PolyData(points=points, lines=_array) rand_walk.insert_next_cell(4, idlist) # VTK_POLY_LINE == 4 writer = tvtk.PolyDataWriter(file_name='run_{}.vtk'.format(pid), input=rand_walk) writer.update()
def marchingcubes(xyzs, file_name, voxel_size=0.05): polydata = tvtk.PolyData() polydata.points = xyzs # set all points as vertices verts = np.arange(0, xyzs.shape[0], 1, 'l') # point ids verts.shape = (xyzs.shape[0], 1) # make it a column vector polydata.verts = verts min, max = (-5, 5) sample_dimensions = (((max - min) / voxel_size),) * 3 voxelModeller = tvtk.ImplicitModeller(sample_dimensions=sample_dimensions, model_bounds=(min, max)*3, maximum_distance=(2*voxel_size/(np.sqrt(3)*(max-min))), output_scalar_type='float', input=polydata) marchingCubes = tvtk.MarchingCubes( input_connection=voxelModeller.output_port, compute_normals=False) marchingCubes.set_value(0, 0.0) polywriter = tvtk.PolyDataWriter(file_name=file_name, input_connection=marchingCubes.output_port) polywriter.write()
def _run_interface(self, runtime): try: from tvtk.api import tvtk except ImportError: raise ImportError('Interface ComputeMeshWarp requires tvtk') try: from enthought.etsconfig.api import ETSConfig ETSConfig.toolkit = 'null' except ImportError: iflogger.warn(('ETS toolkit could not be imported')) pass except ValueError: iflogger.warn(('ETS toolkit is already set')) pass r1 = tvtk.PolyDataReader(file_name=self.inputs.surface1) r2 = tvtk.PolyDataReader(file_name=self.inputs.surface2) vtk1 = r1.output vtk2 = r2.output r1.update() r2.update() assert (len(vtk1.points) == len(vtk2.points)) points1 = np.array(vtk1.points) points2 = np.array(vtk2.points) diff = points2 - points1 weights = np.ones(len(diff)) try: errvector = nla.norm(diff, axis=1) except TypeError: # numpy < 1.9 errvector = np.apply_along_axis(nla.norm, 1, diff) pass if self.inputs.metric == 'sqeuclidean': errvector = errvector**2 if (self.inputs.weighting == 'area'): faces = vtk1.polys.to_array().reshape(-1, 4).astype(int)[:, 1:] for i, p1 in enumerate(points2): # compute surfaces, set in weight w = 0.0 point_faces = faces[(faces[:, :] == i).any(axis=1)] for idset in point_faces: fp1 = points1[int(idset[0])] fp2 = points1[int(idset[1])] fp3 = points1[int(idset[2])] w += self._triangle_area(fp1, fp2, fp3) weights[i] = w result = np.vstack([errvector, weights]) np.save(op.abspath(self.inputs.out_file), result.transpose()) out_mesh = tvtk.PolyData() out_mesh.points = vtk1.points out_mesh.polys = vtk1.polys out_mesh.point_data.vectors = diff out_mesh.point_data.vectors.name = 'warpings' writer = tvtk.PolyDataWriter( file_name=op.abspath(self.inputs.out_warp)) writer.set_input_data(out_mesh) writer.write() self._distance = np.average(errvector, weights=weights) return runtime
def _run_interface(self, runtime): try: from tvtk.api import tvtk except ImportError: raise ImportError('Interface ComputeMeshWarp requires tvtk') try: from enthought.etsconfig.api import ETSConfig ETSConfig.toolkit = 'null' except ImportError: iflogger.warn(('ETS toolkit could not be imported')) pass except ValueError: iflogger.warn(('ETS toolkit is already set')) pass r1 = tvtk.PolyDataReader(file_name=self.inputs.in_surf) vtk1 = r1.output r1.update() points1 = np.array(vtk1.points) if vtk1.point_data.vectors is None: raise RuntimeError(('No warping field was found in in_surf')) operator = self.inputs.operator opfield = np.ones_like(points1) if isinstance(operator, six.string_types): r2 = tvtk.PolyDataReader(file_name=self.inputs.surface2) vtk2 = r2.output r2.update() assert (len(points1) == len(vtk2.points)) opfield = vtk2.point_data.vectors if opfield is None: opfield = vtk2.point_data.scalars if opfield is None: raise RuntimeError( ('No operator values found in operator file')) opfield = np.array(opfield) if opfield.shape[1] < points1.shape[1]: opfield = np.array([opfield.tolist()] * points1.shape[1]).T else: operator = np.atleast_1d(operator) opfield *= operator warping = np.array(vtk1.point_data.vectors) if self.inputs.operation == 'sum': warping += opfield elif self.inputs.operation == 'sub': warping -= opfield elif self.inputs.operation == 'mul': warping *= opfield elif self.inputs.operation == 'div': warping /= opfield vtk1.point_data.vectors = warping writer = tvtk.PolyDataWriter( file_name=op.abspath(self.inputs.out_warp)) writer.set_input_data(vtk1) writer.write() vtk1.point_data.vectors = None vtk1.points = points1 + warping writer = tvtk.PolyDataWriter( file_name=op.abspath(self.inputs.out_file)) writer.set_input_data(vtk1) writer.write() return runtime
def writepolydata(polyd, vtkfile, writer=tvtk.PolyDataWriter()): writer.input = polyd writer.file_name = vtkfile writer.write()
def _run_interface(self, runtime): try: from tvtk.api import tvtk except ImportError: raise ImportError('Interface requires tvtk') r1 = tvtk.PolyDataReader(file_name=self.inputs.in_surf) vtk1 = r1.output r1.update() points1 = np.array(vtk1.points) if vtk1.point_data.vectors is None: raise RuntimeError(('No warping field was found in in_surf')) operator = self.inputs.operator opfield = np.ones_like(points1) if isinstance(operator, string_types): r2 = tvtk.PolyDataReader(file_name=self.inputs.surface2) vtk2 = r2.output r2.update() assert (len(points1) == len(vtk2.points)) opfield = vtk2.point_data.vectors if opfield is None: opfield = vtk2.point_data.scalars if opfield is None: raise RuntimeError( ('No operator values found in operator file')) opfield = np.array(opfield) if opfield.shape[1] < points1.shape[1]: opfield = np.array([opfield.tolist()] * points1.shape[1]).T else: operator = np.atleast_1d(operator) opfield *= operator warping = np.array(vtk1.point_data.vectors) if self.inputs.operation == 'sum': warping += opfield elif self.inputs.operation == 'sub': warping -= opfield elif self.inputs.operation == 'mul': warping *= opfield elif self.inputs.operation == 'div': warping /= opfield vtk1.point_data.vectors = warping writer = tvtk.PolyDataWriter( file_name=op.abspath(self.inputs.out_warp)) if self._vtk_major <= 5: writer.input = vtk1 else: writer.set_input_data_object(vtk1) writer.write() vtk1.point_data.vectors = None vtk1.points = points1 + warping writer = tvtk.PolyDataWriter( file_name=op.abspath(self.inputs.out_file)) if self._vtk_major <= 5: writer.input = vtk1 else: writer.set_input_data_object(vtk1) writer.write() return runtime
def _run_interface(self, runtime): vtk_major = 6 try: import vtk vtk_major = vtk.VTK_MAJOR_VERSION except ImportError: iflogger.warn(('python-vtk could not be imported')) try: from tvtk.api import tvtk except ImportError: raise ImportError('Interface requires tvtk') try: from enthought.etsconfig.api import ETSConfig ETSConfig.toolkit = 'null' except ImportError: iflogger.warn(('ETS toolkit could not be imported')) except ValueError: iflogger.warn(('ETS toolkit could not be set to null')) import nibabel as nb import numpy as np from scipy import ndimage r = tvtk.PolyDataReader(file_name=self.inputs.points) r.update() mesh = r.output points = np.array(mesh.points) warp_dims = nb.funcs.four_to_three(nb.load(self.inputs.warp)) affine = warp_dims[0].get_affine() voxsize = warp_dims[0].get_header().get_zooms() vox2ras = affine[0:3, 0:3] ras2vox = np.linalg.inv(vox2ras) origin = affine[0:3, 3] voxpoints = np.array([np.dot(ras2vox, (p - origin)) for p in points]) warps = [] for axis in warp_dims: wdata = axis.get_data() if np.any(wdata != 0): warp = ndimage.map_coordinates(wdata, voxpoints.transpose()) else: warp = np.zeros((points.shape[0], )) warps.append(warp) disps = np.squeeze(np.dstack(warps)) newpoints = [p + d for p, d in zip(points, disps)] mesh.points = newpoints w = tvtk.PolyDataWriter() if vtk_major <= 5: w.input = mesh else: w.set_input_data_object(mesh) w.file_name = self._gen_fname(self.inputs.points, suffix='warped', ext='.vtk') w.write() return runtime
#!/usr/bin/python import numpy as np from tvtk.api import tvtk from argparse import ArgumentParser from argparse import RawTextHelpFormatter from __future__ import print_function, division, absolute_import, unicode_literals if __name__ == '__main__': parser = ArgumentParser( description='fix vtk mesh in doubles for FreeSurfer', formatter_class=RawTextHelpFormatter) g_input = parser.add_argument_group('Inputs') g_input.add_argument('-i', '--input', action='store', help='input file') g_output = parser.add_argument_group('Outputs') g_output.add_argument('-o', '--output', action='store', help='output file') opts = parser.parse_args() r = tvtk.PolyDataReader(file_name=opts.input) r.update() m = r.output points = np.array(m.points).astype(np.float32) m.points = points w = tvtk.PolyDataWriter(file_name=opts.output) w.set_input_data(m) w.write()