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