def _run_interface(self, runtime):
from tvtk.api import tvtk
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))
d = 0.0
totalWeight = 0.0
points = vtk1.points
faces = vtk1.polys.to_array().reshape(-1, 4).astype(int)[:, 1:]
for p1, p2 in zip(points, vtk2.points):
weight = 1.0
if (self.inputs.weighting == 'surface'):
#compute surfaces, set in weight
weight = 0.0
point_faces = faces[(faces[:, :] == 0).any(axis=1)]
for idset in point_faces:
p1 = points[int(idset[0])]
p2 = points[int(idset[1])]
p3 = points[int(idset[2])]
weight = weight + self._triangle_area(p1, p2, p3)
d += weight * euclidean(p1, p2)
totalWeight = totalWeight + weight
self._distance = d / totalWeight
return runtime
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 setup_vtk_source(fpath):
"""
polydata wrapper reader
"""
dat = tvtk.PolyDataReader(file_name=fpath)
dat.update() # very IMPORTANT!!!
return dat.output
def _run_interface(self, runtime):
try:
from tvtk.api import tvtk
except ImportError:
raise ImportError('Interface P2PDistance requires tvtk')
try:
from enthought.etsconfig.api import ETSConfig
ETSConfig.toolkit = 'null'
except ImportError:
iflogger.warn(('ETS toolkit could not be imported'))
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))
d = 0.0
totalWeight = 0.0
points = vtk1.points
faces = vtk1.polys.to_array().reshape(-1, 4).astype(int)[:, 1:]
for p1, p2 in zip(points, vtk2.points):
weight = 1.0
if (self.inputs.weighting == 'surface'):
# compute surfaces, set in weight
weight = 0.0
point_faces = faces[(faces[:, :] == 0).any(axis=1)]
for idset in point_faces:
p1 = points[int(idset[0])]
p2 = points[int(idset[1])]
p3 = points[int(idset[2])]
weight = weight + self._triangle_area(p1, p2, p3)
d += weight * euclidean(p1, p2)
totalWeight = totalWeight + weight
self._distance = d / totalWeight
return runtime
def get_models_from_dir(models_dir):
classes = os.listdir(models_dir)
models = {}
for c in classes:
model_files = [
f for f in os.listdir(models_dir + '/' + c)
if fnmatch.fnmatch(f, '*.vtk')
]
for m in model_files:
r = tvtk.PolyDataReader()
r.file_name = models_dir + '/' + c + '/' + m
r.update()
models[m] = tvtk.PolyDataMapper(input=r.output)
return models
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 _list_outputs(self):
outputs = self.output_spec().get()
outputs['out_ref'] = op.abspath(self.inputs.out_ref)
outputs['out_tst'] = op.abspath(self.inputs.out_tst)
outputs['max_hd'] = 0.0
outputs['avg_hd'] = 0.0
outputs['std_hd'] = 0.0
outputs['stats_hd'] = [0.0] * 7
try:
from tvtk.api import tvtk
except ImportError:
raise ImportError('Interface HausdorffDistance requires tvtk')
try:
from enthought.etsconfig.api import ETSConfig
ETSConfig.toolkit = 'null'
except ImportError:
iflogger.warn(('ETS toolkit could not be imported'))
pass
try:
r = tvtk.PolyDataReader(file_name=op.abspath(self.inputs.out_ref))
v = r.output
r.update()
points = np.array(v.point_data.get_array('Distance'))
outputs['max_hd'] = points.max()
outputs['avg_hd'] = points.mean()
outputs['std_hd'] = points.std()
outputs['stats_hd'] = [
points.min(),
np.percentile(points, 5.0),
np.percentile(points, 25.0),
np.median(points),
np.percentile(points, 75.0),
np.percentile(points, 95.0),
points.max()
]
except:
iflogger.warn('Hausdorff distance could not be computed')
pass
return outputs
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 readpolydata(vtkfile):
reader = tvtk.PolyDataReader()
reader.file_name = vtkfile
reader.update()
polydata = reader.output
return polydata
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
def from_vtk(cls, prefix):
"""loads mesh from vtk polydata"""
pdr = tvtk.PolyDataReader()
pdr.file_name = "%s_mesh.vtk" % prefix
pdr.update()
return cls.from_polydata(pdr.output)
#!/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()
