def load_polydata(file_name):
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
# todo better generic load
if file_extension == "vtk":
reader = vtk.vtkPolyDataReader()
elif file_extension == "vtp":
reader = vtk.vtkPolyDataReader()
elif file_extension == "fib":
reader = vtk.vtkPolyDataReader()
elif file_extension == "ply":
reader = vtk.vtkPLYReader()
elif file_extension == "stl":
reader = vtk.vtkSTLReader()
elif file_extension == "xml":
reader = vtk.vtkXMLPolyDataReader()
elif file_extension == "obj":
reader = vtk.vtkOBJReader()
#try: # try to read as a normal obj
# reader = vtk.vtkOBJReader()
#except: # than try load a MNI obj format
# reader = vtk.vtkMNIObjectReader()
else:
raise "polydata " + file_extension + " is not suported"
reader.SetFileName(file_name)
reader.Update()
print file_name, " Mesh ", file_extension, "Loaded"
return reader.GetOutput()
def Merge5 ():
reader = vtk.vtkPolyDataReader()
reader.SetFileName('test10.vtk')
reader2 = vtk.vtkPolyDataReader()
reader2.SetFileName('test12.vtk')
reader3 = vtk.vtkPolyDataReader()
reader3.SetFileName('test13.vtk')
app = vtk.vtkAppendPolyData()
app.AddInputConnection(reader.GetOutputPort())
tr = vtk.vtkTransform()
tr.Translate(-50.916666, -1.083333, 0)
tr.RotateZ(90)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(reader2.GetOutputPort())
app.AddInputConnection(tp.GetOutputPort())
tr2 = vtk.vtkTransform()
tr2.Translate(-50.916666, -1.083333, 0)
tp2 = vtk.vtkTransformPolyDataFilter()
tp2.SetTransform(tr2)
tp2.SetInputConnection(reader3.GetOutputPort())
app.AddInputConnection(tp2.GetOutputPort())
return app
def test_airway_particles():
try:
# Get the path to the this test so that we can reference the test data
this_dir = os.path.dirname(os.path.realpath(__file__))
# Set up the inputs to AirwayParticles
input_ct = this_dir + '/../../../Testing/Data/Input/airwaygauss.nrrd'
input_mask = this_dir + '/../../../Testing/Data/Input/airwaygauss_mask.nrrd'
#tmp_dir = this_dir + '/../../../Testing/tmp/'
tmp_dir = tempfile.mkdtemp()
output_particles = os.path.join(tmp_dir,'airway_particles.vtk')
print tmp_dir
max_scale = 6.0
live_th = 40.0
seed_th = 30.0
scale_samples = 5
down_sample_rate = 1.0
min_intensity = -1100
max_intensity = -400
# Generate the airway particles
ap = AirwayParticles(input_ct, output_particles, tmp_dir, input_mask,
max_scale, live_th, seed_th, scale_samples,
down_sample_rate, min_intensity, max_intensity)
ap.execute()
# Read in the reference data set for comparison
ref_reader = vtk.vtkPolyDataReader()
ref_reader.SetFileName(this_dir +
'/../../../Testing/Data/Input/airway_particles.vtk')
ref_reader.Update()
# Now read in the output data set
test_reader = vtk.vtkPolyDataReader()
test_reader.SetFileName(output_particles)
test_reader.Update()
pm = ParticleMetrics(ref_reader.GetOutput(),
test_reader.GetOutput(), 'airway')
assert pm.get_particles_dice() > 0.97, \
"Airway particle Dice score lower than expected"
finally:
#Clear particles cache
ap._clean_tmp_dir=True
ap.clean_tmp_dir()
shutil.rmtree(tmp_dir)
def loadVtk(filename):
if 'vtp' in filename:
vreader = vtk.vtkXMLPolyDataReader()
else:
vreader = vtk.vtkPolyDataReader()
vreader.SetFileName(filename)
vreader.Update()
polydata = vreader.GetOutput()
polydata.ReleaseDataFlagOn()
streamlines = []
verts = vtk_to_numpy(polydata.GetPoints().GetData())
scalars = {}
pointdata = polydata.GetPointData()
for si in range(pointdata.GetNumberOfArrays()):
sname = pointdata.GetArrayName(si)
scalars[sname] = vtk_to_numpy(pointdata.GetArray(si))
for i in range(polydata.GetNumberOfCells()):
pids = polydata.GetCell(i).GetPointIds()
ids = [ pids.GetId(p) for p in range(pids.GetNumberOfIds())]
streamlines.append(ids)
res = {'points':verts, 'values':scalars, 'streamlines':streamlines}
return res
def __init__(self):
self._extension_map = {}
self._all_readers = []
self._reader = vtk.vtkPolyDataReader()
# register file types
self.registerFileTypes()
def CanReadFile(self, filename):
'''
Static methods for I/O
@param filename: str
@rtype: unsigned int
'''
if self.IsMeshExtension(os.path.splitext(filename)[1]):
return self.FILE_IS_VTK
if self.IsOBJExtension(os.path.splitext(filename)[1]):
reader = vtk.vtkOBJReader()
reader.SetFileName(filename)
try:
reader.Update()
except:
# del reader
return 0
# del reader
return self.FILE_IS_OBJ
if not self.IsVtkExtension(os.path.splitext(filename)[1]):
return 0
try:
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
if reader.IsFilePolyData():
# del reader
return self.FILE_IS_VTK
# del reader
except:
pass
return 0
def vtk2vtp(inputfile, outputfile):
"""Read a vtk polydata and save as vtp."""
reader = vtk.vtkPolyDataReader()
reader.SetFileName(inputfile)
reader.Update()
surface = reader.GetOutput()
writevtp(surface,outputfile)
def readMeshFile(filename, verbose=False):
"""Read mesh file.
The input format is determined by file name extension. Degenerate data gets
removed and polygons get split into triangles to support varios restrictive
output formats."""
informat = path.splitext(options.infilename)[1].strip('.')
# set reader based on filename extension
if informat=='stl':
reader = vtk.vtkSTLReader()
elif informat=='vtk':
reader = vtk.vtkPolyDataReader()
elif informat=='obj':
reader = vtk.vtkMNIObjectReader()
#elif informat=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format' + informat)
reader.SetFileName(filename)
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(reader.GetOutputPort())
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(clean.GetOutputPort())
#triangles = reader.GetOutputPort() # skipping above 'cleaning' doesn't work
if verbose:
print "read", filename
return triangles
def load_streamlines_poyldata(file_name):
# get file extension (type)
reader = vtk.vtkPolyDataReader()
reader.SetFileName(file_name)
reader.Update()
line_data = reader.GetOutput()
return line_data
def convert_mris(input_name, output_name):
"""
Converts a FreeSurfer surface to VTK file format
"""
# convert surface to VTK format
if output_name.endswith('.vtp'): temp_name = output_name[0:-1] + 'k'
else: temp_name = output_name
if not temp_name.endswith('.vtk'):
raise RuntimeError('Output file name extension must be either .vtk or .vtp')
check_call(['mris_convert', input_name, temp_name])
# get surface RAS translation
out = check_output(["mris_info", input_name], stderr=STDOUT)
m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out)
if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!')
tx = float(m.group(1))
ty = float(m.group(2))
tz = float(m.group(3))
# transform vertex positions to scanner RAS of orig.mgz
reader = vtkPolyDataReader()
reader.SetFileName(temp_name)
reader.Update()
surface = reader.GetOutput()
points = surface.GetPoints()
for i in range(points.GetNumberOfPoints()):
x, y, z = points.GetPoint(i)
points.SetPoint(i, x + tx, y + ty, z + tz)
surface.SetPoints(points)
if output_name.endswith('.vtp'): writer = vtkXMLPolyDataWriter()
else: writer = vtkPolyDataWriter()
writer.SetFileName(output_name)
writer.SetInput(surface)
writer.Write()
if temp_name != output_name:
remove(temp_name)
def __init__(self, module_manager):
"""Constructor (initialiser) for the PD reader.
This is almost standard code for most of the modules making use of
the FilenameViewModuleMixin mixin.
"""
# call the constructor in the "base"
ModuleBase.__init__(self, module_manager)
# setup necessary VTK objects
self._reader = vtk.vtkPolyDataReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'VTK data (*.vtk)|*.vtk|All files (*)|*',
{'vtkPolyDataReader': self._reader})
module_utils.setup_vtk_object_progress(
self, self._reader,
'Reading vtk polydata')
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def read_polydata(filename):
"""Read whole-brain tractography as vtkPolyData format."""
if VERBOSE:
print "Reading in data from", filename, "..."
basename, extension = os.path.splitext(filename)
if (extension == '.vtk'):
reader = vtk.vtkPolyDataReader()
elif (extension == '.vtp'):
reader = vtk.vtkXMLPolyDataReader()
else:
print 'Cannot recognize model file format'
return None
reader.SetFileName(filename)
reader.Update()
outpd = reader.GetOutput()
del reader
if VERBOSE:
print "Done reading in data from", filename
print "Number of lines found:", outpd.GetNumberOfLines()
return outpd
def readPData(
filename,
verbose=1):
myVTK.myPrint(verbose, "*** readPData: "+filename+" ***")
assert (os.path.isfile(filename)), "Wrong filename (\""+filename+"\"). Aborting."
if ('vtk' in filename):
pdata_reader = vtk.vtkPolyDataReader()
elif ('vtp' in filename):
pdata_reader = vtk.vtkXMLPolyDataReader()
else:
assert 0, "File must be .vtk or .vtp. Aborting."
pdata_reader.SetFileName(filename)
pdata_reader.Update()
pdata = pdata_reader.GetOutput()
myVTK.myPrint(verbose-1, "n_points = "+str(pdata.GetNumberOfPoints()))
myVTK.myPrint(verbose-1, "n_verts = "+str(pdata.GetNumberOfVerts()))
myVTK.myPrint(verbose-1, "n_lines = "+str(pdata.GetNumberOfLines()))
myVTK.myPrint(verbose-1, "n_polys = "+str(pdata.GetNumberOfPolys()))
myVTK.myPrint(verbose-1, "n_strips = "+str(pdata.GetNumberOfStrips()))
return pdata
def mris2vtk(input_name, output_name):
"""
Converts a FreeSurfer surface to VTK file format
"""
# convert surface to VTK format
check_call(['mris_convert', input_name, output_name])
# get surface RAS translation
out = check_output(["mris_info", input_name], stderr=STDOUT)
m = re.search("c_\(ras\)\s:\s\((-?\d+\.\d+),\s(-?\d+\.\d+),\s(-?\d+\.\d+)\)", out)
if m is None: raise RuntimeError('Could not find c_(ras) coordinates in mris_info output!')
tx = float(m.group(1))
ty = float(m.group(2))
tz = float(m.group(3))
# transform vertex positions to scanner RAS of orig.mgz
reader = vtkPolyDataReader()
reader.SetFileName(output_name)
reader.Update()
surface = reader.GetOutput()
points = surface.GetPoints()
for i in range(points.GetNumberOfPoints()):
x, y, z = points.GetPoint(i)
points.SetPoint(i, x + tx, y + ty, z + tz)
surface.SetPoints(points)
writer = vtkPolyDataWriter()
writer.SetFileName(output_name)
writer.SetInput(surface)
writer.Write()
def vtk2objfcn(vtkfile,objfile,decimFactor):
import vtk
import random
from math import *
import numpy
obj = open(objfile,'w')
reader = vtk.vtkPolyDataReader()
reader.SetFileName(vtkfile)
reader.Update()
out = reader.GetOutput()
verttotal = 0
#print out.GetNumberOfLines()
for i in xrange(0,out.GetNumberOfLines()-1,decimFactor):
bounds = out.GetCell(i).GetBounds()
for j in range(out.GetCell(i).GetNumberOfPoints()):
voutstr = "v %7.3f %7.3f %7.3f\n" % (out.GetPoint(out.GetCell(i).GetPointId(j))[0]-90.,out.GetPoint(out.GetCell(i).GetPointId(j))[1]-126.,out.GetPoint(out.GetCell(i).GetPointId(j))[2]-72.)
obj.write(voutstr)
loutstr = 'l'
for k in range(out.GetCell(i).GetNumberOfPoints()-1):
loutstr += ' %7d' % (k+1+verttotal)
loutstr += '\n'
obj.write(loutstr)
verttotal += out.GetCell(i).GetNumberOfPoints()
obj.close()
print('Done!')
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkPolyDataReader(), 'Reading vtkPolyData.',
(), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def PolyDataReader(self, currentElement):
reader = vtk.vtkPolyDataReader()
try:
reader.SetFileName(os.path.join(self.basedir, currentElement.get('SetFileName')))
except:
self.logger.error(' .. <PolyDataReader> failed to SetFileName')
return reader
def read_vtkPolyData(filename):
r'''
Reads a VTKPolyData file and outputs a tracts/tracts_data pair
Parameters
----------
filename : str
VTKPolyData filename
Returns
-------
tracts : list of float array N_ix3
Each element of the list is a tract represented as point array,
the length of the i-th tract is N_i
tract_data : dict of <data name>= list of float array of N_ixM
Each element in the list corresponds to a tract,
N_i is the length of the i-th tract and M is the
number of components of that data type.
'''
if filename.endswith('xml') or filename.endswith('vtp'):
polydata_reader = vtk.vtkXMLPolyDataReader()
else:
polydata_reader = vtk.vtkPolyDataReader()
polydata_reader.SetFileName(filename)
polydata_reader.Update()
polydata = polydata_reader.GetOutput()
return vtkPolyData_to_tracts(polydata)
def get_num_fibers(filename):
#reader = vtk.vtkDataSetReader()
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
reader.Update()
nlines = reader.GetOutput().GetNumberOfLines()
return nlines
def MeshToVolume(Filename):
reader = vtk.vtkPolyDataReader()
pol2stenc = vtk.vtkPolyDataToImageStencil()
imgstenc = vtk.vtkImageStencil()
reader.SetFileName(os.path.join(subjects_dir,subject_dir,Filename))
reader.Update()
ref_mesh = reader.GetOutput()
ref_volume = vtk.vtkImageData()
# define output volume dimension
spacing = (0.5,0.5,0.5)
ref_volume.SetSpacing(spacing)
bounds = ref_mesh.GetBounds()
dim = [math.ceil(bounds[ii*2+1] - bounds[ii*2] / spacing[ii]) for ii in range(0,3)]
origin = [bounds[ii*2] + spacing[ii] / 2 for ii in range(0,3)]
extent = (0,dim[0] - 1,0,dim[1] -1 ,0,dim[2]-1)
ref_volume.SetOrigin(origin)
ref_volume.SetDimensions(dim)
ref_volume.SetExtent(extent)
ref_volume.SetScalarTypeToUnsignedChar()
ref_volume.AllocateScalars()
# Fill the image with white voxels
for i in range(0,ref_volume.GetNumberOfPoints()):
ref_volume.GetPointData().GetScalars().SetTuple1(i,255)
print ref_volume.GetNumberOfPoints()
pol2stenc.SetInput(ref_mesh)
pol2stenc.SetOutputOrigin(origin)
pol2stenc.SetOutputSpacing(spacing)
pol2stenc.SetOutputWholeExtent(ref_volume.GetExtent())
pol2stenc.Update()
imgstenc.SetInput(ref_volume)
imgstenc.SetStencil(pol2stenc.GetOutput())
imgstenc.ReverseStencilOff()
imgstenc.SetBackgroundValue(0)
imgstenc.Update()
tmp = imgstenc.GetOutput()
writer = vtk.vtkImageWriter()
writer.SetFileName('prova.nii.gz')
writer.SetInput(ref_volume)
writer.Update()
out = v2n(tmp.GetPointData().GetScalars())
return np.reshape(out, (dim[0],dim[1],dim[2]))
def ReadVTKSurfaceFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading VTK surface file.')
reader = vtk.vtkPolyDataReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Surface = reader.GetOutput()
def getReader(self, model_type=None):
self.model_type = model_type
if self.model_type == 'UnstructuredGrid':
return vtk.vtkUnstructuredGridReader()
elif self.model_type == 'PolyData':
return vtk.vtkPolyDataReader()
else:
raise ValueError("model type informed is unknow...")
def readVTK(filename):
#read the vtk file with an unstructured grid
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
return reader
def read_vtkpd(filename):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
reader.Update()
pd = vtk.vtkPolyData()
pd.ShallowCopy(reader.GetOutput())
return pd
def Merge3 ():
reader = vtk.vtkPolyDataReader()
reader.SetFileName('test0.vtk')
reader2 = vtk.vtkPolyDataReader()
reader2.SetFileName('test1.vtk')
reader3 = vtk.vtkPolyDataReader()
reader3.SetFileName('test2.vtk')
reader4 = vtk.vtkPolyDataReader()
reader4.SetFileName('test3.vtk')
app = vtk.vtkAppendPolyData()
app.AddInputConnection(reader.GetOutputPort())
tr = vtk.vtkTransform()
tr.RotateZ(90)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(reader2.GetOutputPort())
app.AddInputConnection(tp.GetOutputPort())
tr2 = vtk.vtkTransform()
tr2.Translate(43.333333, 3.25, 0)
tp2 = vtk.vtkTransformPolyDataFilter()
tp2.SetTransform(tr2)
tp2.SetInputConnection(reader3.GetOutputPort())
app.AddInputConnection(tp2.GetOutputPort())
tr3 = vtk.vtkTransform()
tr3.Translate(43.333333, 3.25, 0)
tr3.RotateZ(90)
tp3 = vtk.vtkTransformPolyDataFilter()
tp3.SetTransform(tr3)
tp3.SetInputConnection(reader4.GetOutputPort())
app.AddInputConnection(tp3.GetOutputPort())
return app
def read_paths(fold):
print fold
fname = fold+'/pathsq.vtk'
print fname
npArray = fold+'/pathsq' # fname = '/home/florian/MEGAsync/calcul/LCS_tractor/data/paths.vtk'
if os.path.isfile(npArray + '.npy'):
print 'loading ', npArray
t0 = time.time()
xx = np.load(npArray + '.npy')
print 'already existing array loaded in', time.time() - t0, 's'
else:
reader = vtk.vtkPolyDataReader()
reader.SetFileName(fname)
reader.Update()
data = reader.GetOutput()
ll = data.GetLines()
n_pts = ll.GetSize() # nb of points
n_lines = ll.GetNumberOfCells() # nb of lines
idList = vtk.vtkIdList()
idList.SetNumberOfIds(n_lines)
print idList
idList.SetId(0, 0)
abscissaArray = vtk.vtkFloatArray()
traj = [] # list of pos
vel = [] # list of vel
vort = [] # list of vort
k = 0
for i in xrange(n_lines):
cell = data.GetCell(i)
abscissa = 0.0
previousPoint = None
if i % np.int(n_lines / 100) == 0:
print k, '% read'
k += 1
llength = cell.GetNumberOfPoints()
pos = [] # np.empty([llength, 3]) # pos, u, vort
u = [] # np.empty([llength, 3]) # pos, u, vort
vorti = [] # np.empty([llength]) # pos, u, vort
for j in range(llength):
pointId = cell.GetPointId(j)
pos.append(data.GetPoint(pointId))
u.append(vtk_to_numpy(data.GetPointData().GetArray("U"))[pointId])
vorti.append(vtk_to_numpy(data.GetPointData().GetArray("Vorticity"))[pointId])
traj.append(pos)
vel.append(u)
vort.append(vorti)
# print traj
# x = [traj, vel, vort]
xx = np.array([traj,vel,vort])
np.save(npArray, xx)
print 'shit\'s read'
print 'end of path lines reading'
return xx
def readVTKPD(fn): ''' reads a vtk polydata object from a file ''' pd_reader = vtk.vtkPolyDataReader() pd_reader.SetFileName(fn) pd_reader.Update() pd = pd_reader.GetOutput() return pd
def __init__(self, dataDir = 'data', streamFile = 'stream.vtk'):
"""
Read the initial streamlines.
call signature:
readStream(dataDir = 'data', streamFile = 'stream.vtk')
Keyword arguments:
*dataDir*:
Data directory.
*streamFile*:
Read the initial streamline from this file.
"""
# load the data
reader = vtk.vtkPolyDataReader()
reader.SetFileName(dataDir + '/' + streamFile)
reader.Update()
output = reader.GetOutput()
# get the fields
field = output.GetFieldData()
nArrays = field.GetNumberOfArrays()
class params: pass
p = params()
for i in range(nArrays):
arrayName = field.GetArrayName(i)
if any(arrayName == np.array(['l', 'sl'])):
setattr(self, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName)))
elif any(arrayName == np.array(['hMin', 'hMax', 'lMax', 'tol', 'iterMax', 'nt'])):
setattr(self, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName))[0])
else:
# change this if parameters can have more than one entry
setattr(p, arrayName, VN.vtk_to_numpy(field.GetArray(arrayName))[0])
setattr(self, 'p', p)
# get the points
points = output.GetPoints()
pointsData = points.GetData()
data = VN.vtk_to_numpy(pointsData)
#data = np.swapaxes(data, 0, 1)
print self.nt
print self.sl
print data.shape
tracers = np.zeros([self.nt, np.max(self.sl), 3], dtype = data.dtype)
sl = 0
for i in range(self.nt):
#if (i > 0):
#sl = self.sl[i-1]
#else:
#sl = 0
print sl, self.sl[i]
tracers[i,:self.sl[i],:] = data[sl:sl+self.sl[i],:]
sl += self.sl[i]
setattr(self, 'tracers', tracers)
def execute(self):
for kk,file_name in enumerate(self.file_list):
reader=vtk.vtkPolyDataReader()
reader.SetFileName(file_name)
reader.Update()
poly = self.compute_radius(reader.GetOutput(),spacing_list[kk])
if self.use_field_data == False:
poly.GetPointData().\
SetNormals(poly.GetPointData().\
GetArray(self.normal_map[self.feature_type]))
else:
poly.GetPointData().\
SetNormals(poly.GetFieldData().\
GetArray(self.normal_map[self.feature_type]))
glypher=self.create_glyphs(poly)
if len(self.color_list) <= kk:
color=[]
else:
color=self.color_list[kk]
if len(self.opacity_list) <= kk:
opacity=1
else:
opacity=self.opacity_list[kk]
self.create_actor(glypher,color=color,opacity=opacity)
if len(self.lung)>0:
reader=vtk.vtkPolyDataReader()
reader.SetFileName(self.lung)
reader.Update()
tt=vtk.vtkTransform()
tt.Identity()
tt.GetMatrix().SetElement(0,0,-1)
tt.GetMatrix().SetElement(1,1,-1)
tf=vtk.vtkTransformPolyDataFilter()
tf.SetTransform(tt)
tf.SetInput(reader.GetOutput())
tf.SetTransform(tt)
self.create_actor(tf,0.1,color=[0.8,0.4,0.01])
self.add_color_bar()
self.render()
def load_velocity(filename):
import os
if not os.path.exists(filename):
return None
from numpy import zeros
from vtk import vtkPolyDataReader, vtkCellDataToPointData
reader = vtkPolyDataReader()
reader.SetFileName(filename)
reader.ReadAllVectorsOn()
reader.Update()
data = reader.GetOutput()
# Extracting triangulation information
triangles = data.GetPolys().GetData()
points = data.GetPoints()
# Mapping data: cell -> point
mapper = vtkCellDataToPointData()
mapper.AddInputData(data)
mapper.Update()
mapped_data = mapper.GetOutput()
# Extracting interpolate point data
udata = mapped_data.GetPointData().GetArray(0)
ntri = triangles.GetNumberOfTuples()/4
npts = points.GetNumberOfPoints()
nvls = udata.GetNumberOfTuples()
tri = zeros((ntri, 3))
x = zeros(npts)
y = zeros(npts)
ux = zeros(nvls)
uy = zeros(nvls)
for i in xrange(0, ntri):
tri[i, 0] = triangles.GetTuple(4*i + 1)[0]
tri[i, 1] = triangles.GetTuple(4*i + 2)[0]
tri[i, 2] = triangles.GetTuple(4*i + 3)[0]
for i in xrange(npts):
pt = points.GetPoint(i)
x[i] = pt[0]
y[i] = pt[1]
for i in xrange(0, nvls):
U = udata.GetTuple(i)
ux[i] = U[0]
uy[i] = U[1]
return (x, y, tri, ux, uy)
def load_vtk(filename):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def onInputShapesDirectoryChanged(self):
inputShapesDirectory = self.shapeInputDirectory.directory.encode('utf-8')
# Set this directory as the default output directory as well
self.outputDirectory.directory = str(inputShapesDirectory)
row = 0
allShapeSigmaWs = []
for curFile in sorted(os.listdir(inputShapesDirectory)):
if not (curFile.endswith(".vtk")):
continue
self.tableWidget_inputShapeParameters.setRowCount(row + 1)
# Read the vtk file to set a default kernel width
shapeFile = '%s/%s' %(inputShapesDirectory, curFile)
polyReader = vtk.vtkPolyDataReader()
polyReader.SetFileName(shapeFile)
polyReader.Update()
shape = polyReader.GetOutput()
shapeBounds = shape.GetBounds()
xRange = shapeBounds[1] - shapeBounds[0]
yRange = shapeBounds[3] - shapeBounds[2]
zRange = shapeBounds[5] - shapeBounds[4]
smallestRange = min(xRange, yRange, zRange)
initSigmaW = int(smallestRange*0.50)
allShapeSigmaWs.append(initSigmaW)
# Try to extract the time point as a suffix
curTimePoint = 0.0
numsInFilename = re.findall(r'[-+]?\d*\.\d+|\d+', curFile)
if (len(numsInFilename) > 0):
curTimePoint = numsInFilename[-1] # We assume the final number in the filename is the time point
# Column 0:
#rootname = os.path.basename(curFile).split(".")[0]
rootname = os.path.splitext(os.path.basename(curFile))[0]
labelVTKFile = qt.QLabel(rootname)
labelVTKFile.setAlignment(0x84)
self.tableWidget_inputShapeParameters.setCellWidget(row, 0, labelVTKFile)
# Column 1-2-3-4: (Time Point, Sigma W, Tris, Weight)
# We might want to consider using different UI elements for Time Point and Kernel Width that do not have explicit ranges
for column in range(1,5):
widget = qt.QWidget()
layout = qt.QHBoxLayout(widget)
# If this is the 'Shape Index' column we limit this to an integer
if (column == 3):
spinBox = qt.QSpinBox()
spinBox.setRange(0,1000)
spinBox.value = 0
# The rest of the columns are doubles
else:
spinBox = qt.QDoubleSpinBox()
if column == 1: # Time Point
spinBox.value = float(curTimePoint)
spinBox.connect('valueChanged(double)', self.onSetTimePointRange)
spinBox.setRange(-1e10, 1e10)
if column == 2: # Kernel Width
spinBox.setRange(0.001, 1e10)
spinBox.value = initSigmaW
if column == 4: # Weight
spinBox.value = 1
spinBox.setRange(0,1)
spinBox.setSingleStep(0.1);
layout.addWidget(spinBox)
layout.setAlignment(0x84)
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
self.tableWidget_inputShapeParameters.setCellWidget(row, column, widget)
row = row + 1
# We can set a default for deformation kernel width as smallest shape kernel
self.defKernelWidth.value = min(allShapeSigmaWs)
# Update the time range (if time point suffixes provided initialization)
self.onSetTimePointRange()
def mitograph_extended_analysis(directory, cellID, genotype, timespace,
switchpoint, refeed):
if os.path.isdir(directory) != 1:
raise Exception(
"Error: Input directory is not a valid directory name.")
# collect a list of all surface reconstructions to be analyzed
directory_contents = sorted(os.listdir(directory))
surfaces = []
for file in directory_contents:
if file.endswith('surface.vtk'):
surfaces += [file]
# specifies the volume threshold used to distinguish mitochondria
# from cellular debris, hot pixels, and other non-mitochondrial noise
# units are cubed microns
# number of objects falling below this threshold in each cell is recorded
minvol = 0.0250
# specifies a minimum size to be counted as a potential artifact
# number of potential artifacts will be used downstream to identify segmentation artifacts on a whole-cell level
minartifact = 0.045
# specifies a maximum volume threshold used to distinguish cells
# from massive, overly-segmented background noise
maxvol = 10000
with open((directory + '/' + os.path.basename(directory) +
'_morphological_summaries_by_mitochondrion.txt'),
'wb') as csv_ind:
ind_csv_writer = csv.writer(csv_ind, csv.excel_tab)
ind_csv_writer.writerow(['mitograph_extended_analysis_v11.py'])
ind_csv_writer.writerow(['directory: ' + directory])
ind_csv_writer.writerow(
['minimum volume threshold for mitochondrion: ' + str(minvol)])
ind_csv_writer.writerow(
['maximum volume threshold for cell: ' + str(maxvol)])
ind_csv_writer.writerow('')
ind_csv_writer.writerow([
'image path', 'cellID', 'genotype', 'time', 'mitochondrion',
'volume (um^3)', 'surface area (um^2)', 'normalized shape index',
'sphericity', 'compactedness'
])
csv_ind.close()
with open((directory + '/' + os.path.basename(directory) +
'_morphological_summaries_by_whole_cell.txt'),
'wb') as csv_totals:
total_csv_writer = csv.writer(csv_totals, csv.excel_tab)
total_csv_writer.writerow(['mitograph_extended_analysis_v11.py'])
total_csv_writer.writerow(['directory: ' + directory])
total_csv_writer.writerow(
['minimum volume threshold for mitochondrion: ' + str(minvol)])
total_csv_writer.writerow(
['maximum volume threshold for cell: ' + str(maxvol)])
total_csv_writer.writerow('')
total_csv_writer.writerow([
'image path', 'cellID', 'genotype', 'time',
'total number of mitochondria',
'total mitochondrial volume (um^3)',
'total mitochondrial surface area (um^2)',
'total normalized shape index', 'total sphericity',
'total length (um)', 'average volume of mitochondrion (um^3)',
'average surface area of mitochondrion (um^2)',
'average NSI of mitochondrion',
'average sphericity of mitochondrion',
'volume-weighted average surface area of mitochondria (um^2)',
'volume-weighted average NSI of mitochondrion',
'volume-weighted average sphericity of mitochondrion',
'average compactedness of mitochondrion',
'volume-weighted average compactedness of mitochondrion',
'average width (um)', 'std width (um)', 'number of endpoints',
'artifacts'
])
csv_totals.close()
for surface in surfaces:
surface_and_path = directory + '/' + surface
stagename = surface.split('_')[-5]
stagepos = (stagename[1:]).zfill(2)
# read in contents of .vtk file as polydata
reader = vtk.vtkPolyDataReader()
filename = '\'' + surface_and_path + '\''
print('processing file: ' + filename)
reader.SetFileName(surface_and_path)
reader.Update()
# determine the time, in minutes
# times prior to glucose withdrawal are expressed as a function of time until withdrawal
# e.g., -15 minutes
# times following glucose return are recorded as strings preceded by r
# e.g., 'r60' minutes
# remember that time here is 1-indexed, making this work counterintuitively
# extract timepoint number from file name
timepos = int(filename[-25:-22])
# if the timepoint, converted into minutes since initiation,
# is earlier than glucose return, then calculate time as the difference
# between the timepoint number and timepoint of glucose withdrawal, times the time interval
if (((timepos - 1) * timespace) < (refeed * 60)) or refeed == 'NA':
time = (timepos - 1 - (switchpoint * 60 / timespace)) * timespace
# if post-refeeding:
# calculate time as the difference between the timepoint number and timepoint of
# glucose refeeding, times the time interval
else:
time = 'r' + str(
(timepos - 1 - (refeed * 60 / timespace)) * timespace)
# convert to triangle mesh
triangulated = vtk.vtkTriangleFilter()
triangulated.SetInputConnection(reader.GetOutputPort())
triangulated.Update()
# test whether the entire cell exceeds the maximum volume ceiling indicating background segmentation
# if so, proceed directly to the next iteration of the loop on the next surface
massvol_test = vtk.vtkMassProperties()
massvol_test.SetInputConnection(triangulated.GetOutputPort())
massvol_test.Update()
test_vol = massvol_test.GetVolume()
if test_vol >= maxvol:
continue
else:
# apply connectivity filter; extract number of distinct mitochondria
connect_filter = vtk.vtkPolyDataConnectivityFilter()
connect_filter.SetInputConnection(triangulated.GetOutputPort())
connect_filter.Update()
mitochondria = connect_filter.GetNumberOfExtractedRegions()
# initialize dictionaries containing connectivity filter output; massproperties;
# and shape descriptives for individual mitochondria, to be keyed by region number
mitochonnectdict = {}
masspropdict = {}
volumes = {}
surface_areas = {}
NSIs = {}
sphericity = {}
compacteds = {}
avgvolume = 0
avgSA = 0
avgNSI = 0
avgsphericity = 0
avgcompacted = 0
weighted_avgSA = 0
weighted_avgNSI = 0
weighted_avgsphericity = 0
weighted_avgcompacted = 0
total_volume = 0
total_length = 'NA'
total_surface_area = 0
avg_width = 'NA'
std_width = 'NA'
endpoints = 'NA'
# initializes a count of segmented objects that meet a size threshold requirement
# as a noise elimination step to remove non-mitochondrial junk
threshmitos = 0
# searches for mitograph summary file
# if it exists: find the network length associated with the cell
skeleton_and_path = directory + '/summary.txt'
if os.path.isfile(skeleton_and_path):
df = pd.read_csv(skeleton_and_path, skiprows=8, sep='\t')
skelname = '///' + surface[:-12]
total_length = float(
df[df.Image.str.endswith(skelname)]['total_length_(um)'])
avg_width = float(
df[df.Image.str.endswith(skelname)]['avg_width_(um)'])
std_width = float(
df[df.Image.str.endswith(skelname)]['std_width_(um)'])
endpoints = float(
df[df.Image.str.endswith(skelname)]['#Endpoints'])
artifacts = 0
for i in range(mitochondria):
# cycle through individual mitochondria identified by connectivity filter
# partition via multiple connectivity filters
# save filters in a dictionary keyed to each connectivity region
key = i
mitochonnectdict[key] = vtk.vtkPolyDataConnectivityFilter()
mitochonnectdict[key].SetInputConnection(
triangulated.GetOutputPort())
mitochonnectdict[key].Update()
mitochonnectdict[key].SetExtractionModeToSpecifiedRegions()
mitochonnectdict[key].AddSpecifiedRegion(i)
mitochonnectdict[key].Update()
# create a vtkmassproperties class for each separate connectivity partition
# save each instance in a dictionary keyed to each connectivity region
masspropdict[key] = vtk.vtkMassProperties()
masspropdict[key].SetInputConnection(
mitochonnectdict[key].GetOutputPort())
masspropdict[key].Update()
# calculate the volume of the mitochondrion
testvol = masspropdict[key].GetVolume()
# if it falls below the artifact threshold: record as an artifact
if testvol <= minartifact:
artifacts += 1
# test whether the volume of the mitochondrion surpasses the threshold size
# if yes: proceed with morphological analysis and iterate real mitochondrial count
# if no: break for loop and proceed to next cell
if testvol <= minvol:
continue
else:
# extract volume, surface area, and normalized shape index from massproperties class
t = threshmitos
volumes[t] = masspropdict[key].GetVolume()
surface_areas[t] = masspropdict[key].GetSurfaceArea()
NSIs[t] = masspropdict[key].GetNormalizedShapeIndex()
compacteds[t] = np.power(surface_areas[t], 1.5) / float(
volumes[t])
total_volume += volumes[t]
avgvolume += volumes[t]
avgcompacted += compacteds[t]
total_surface_area += surface_areas[t]
avgSA += surface_areas[t]
avgNSI += NSIs[t]
# calculate sphericity
sphericity[t] = (np.power(np.pi, (1.0 / 3.0)) * np.power(
(6 * volumes[t]),
(2.0 / 3.0))) / float(surface_areas[t])
avgsphericity += sphericity[t]
# add the product of volume and surface area, normalized shape index, or sphericity
# to a running calculation of averages of shape parameters weighted by volume
weighted_avgSA += (volumes[t] * surface_areas[t])
weighted_avgNSI += (volumes[t] * NSIs[t])
weighted_avgsphericity += (volumes[t] * sphericity[t])
weighted_avgcompacted += (volumes[t] * compacteds[t])
# add this mitochondrion to the count of confirmed mitochondrial structures
threshmitos += 1
# write measurements of individual mitochondria to a csv file
with open((directory + '/' + os.path.basename(directory) +
'_morphological_summaries_by_mitochondrion.txt'),
'a') as csv_ind:
ind_csv_writer = csv.writer(csv_ind, csv.excel_tab)
for j in range(threshmitos):
ind_csv_writer.writerow([
surface[:-12], (cellID + stagepos + filename[-16:-13]),
genotype, time, (j + 1), volumes[j], surface_areas[j],
NSIs[j], sphericity[j], compacteds[j]
])
csv_ind.close()
# perform massproperties calculations for bulk mitochondrial content in cell
# note that total volume and surface area were calculated previously from thresholded mitochondrial content
total_massproperties = vtk.vtkMassProperties()
total_massproperties.SetInputConnection(
triangulated.GetOutputPort())
total_massproperties.Update()
#total_volume = total_massproperties.GetVolume()
#total_surface_area = total_massproperties.GetSurfaceArea()
total_NSI = total_massproperties.GetNormalizedShapeIndex()
total_sphericity = (np.power(np.pi, (1.0 / 3.0)) * np.power(
(6 * total_volume), (2.0 / 3.0))) / float(total_surface_area)
# get cell-averaged data
avgvolume = avgvolume / float(threshmitos)
avgSA = avgSA / float(threshmitos)
avgNSI = avgNSI / float(threshmitos)
avgsphericity = avgsphericity / float(threshmitos)
# get cell-averaged data weighted by mitochondrion volume
if total_volume > 0:
weighted_avgSA = weighted_avgSA / float(total_volume)
weighted_avgNSI = weighted_avgNSI / float(total_volume)
weighted_avgsphericity = weighted_avgsphericity / float(
total_volume)
weighted_avgcompacted = weighted_avgcompacted / float(
total_volume)
else:
weighted_avgSA = 0
weighted_avgNSI = 0
weighted_avgsphericity = 0
weighted_avgcompacted = 0
# write cell-total and cell-averaged output to a second csv file
with open((directory + '/' + os.path.basename(directory) +
'_morphological_summaries_by_whole_cell.txt'),
'a') as csv_totals:
total_csv_writer = csv.writer(csv_totals, csv.excel_tab)
total_csv_writer.writerow([
surface[:-12], (cellID + stagepos + filename[-16:-13]),
genotype, time, threshmitos, total_volume,
total_surface_area, total_NSI, total_sphericity,
total_length, avgvolume, avgSA, avgNSI, avgsphericity,
weighted_avgSA, weighted_avgNSI, weighted_avgsphericity,
avgcompacted, weighted_avgcompacted, avg_width, std_width,
endpoints, artifacts
])
csv_totals.close()
print('Analysis complete!')
#!/usr/bin/env python
import sys
import vtk
if (len(sys.argv) == 1):
print "This script should at least contain 1 argument.\nUsage: vtkpython vtktovtp.py $inputFile"
sys.exit()
path = sys.argv[1]
opath = "/tmp/tmp.vtp"
if len(sys.argv) > 2:
opath = sys.argv[3]
reader = vtk.vtkPolyDataReader()
reader.SetFileName(path)
reader.Update()
input = reader.GetOutput()
nPoints = input.GetNumberOfPoints()
nCells = input.GetNumberOfCells()
print "Input Mesh \nPoints: " + str(nPoints) + "\nCells: " + str(nCells)
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInput(input)
writer.SetFileName(opath)
writer.SetDataModeToAscii()
writer.Write()
def testDeciFranFace(self):
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
ren3 = vtk.vtkRenderer()
ren4 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
renWin.AddRenderer(ren3)
renWin.AddRenderer(ren4)
pnm1 = vtk.vtkPNGReader()
pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png")
atext = vtk.vtkTexture()
atext.SetInputConnection(pnm1.GetOutputPort())
atext.InterpolateOn()
# create a cyberware source
#
fran = vtk.vtkPolyDataReader()
fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk")
# Create a table of decimation conditions
#
boundaryVertexDeletion = ["On", "Off"]
accumulates = ["On", "Off"]
deci = dict()
mapper = dict()
actor = dict()
for topology in boundaryVertexDeletion:
for accumulate in accumulates:
idx = topology + accumulate
deci.update({idx: vtk.vtkDecimatePro()})
deci[idx].SetInputConnection(fran.GetOutputPort())
deci[idx].SetTargetReduction(.95)
if topology == "On":
deci[idx].PreserveTopologyOn()
elif topology == "Off":
deci[idx].PreserveTopologyOff()
if accumulate == "On":
deci[idx].AccumulateErrorOn()
elif accumulate == "Off":
deci[idx].AccumulateErrorOff()
mapper.update({idx: vtk.vtkPolyDataMapper()})
mapper[idx].SetInputConnection(deci[idx].GetOutputPort())
actor.update({idx: vtk.vtkActor()})
actor[idx].SetMapper(mapper[idx])
actor[idx].SetTexture(atext)
# Add the actors to the renderer, set the background and size
#
ren1.SetViewport(0, .5, .5, 1)
ren2.SetViewport(.5, .5, 1, 1)
ren3.SetViewport(0, 0, .5, .5)
ren4.SetViewport(.5, 0, 1, .5)
ren1.AddActor(actor["OnOn"])
ren2.AddActor(actor["OnOff"])
ren3.AddActor(actor["OffOn"])
ren4.AddActor(actor["OffOff"])
camera = vtk.vtkCamera()
ren1.SetActiveCamera(camera)
ren2.SetActiveCamera(camera)
ren3.SetActiveCamera(camera)
ren4.SetActiveCamera(camera)
ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225)
ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847,
-5.84226e-09)
ren1.GetActiveCamera().SetViewAngle(30)
ren1.GetActiveCamera().SetViewUp(0, 1, 0)
ren1.ResetCameraClippingRange()
ren2.ResetCameraClippingRange()
ren3.ResetCameraClippingRange()
ren4.ResetCameraClippingRange()
ren1.SetBackground(1, 1, 1)
ren2.SetBackground(1, 1, 1)
ren3.SetBackground(1, 1, 1)
ren4.SetBackground(1, 1, 1)
renWin.SetSize(500, 500)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "deciFranFace.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
age_i = sorted_ageArr[idx]
label_i = sorted_labelArr[idx]
subjFolderPath = dataFolderPath + "PHD-AS1-" + subj_i + "/" + label_i + "/surfaces/decimated_aligned/"
Haus_EGReg_i = 0
Haus_LReg_i = 0
Haus_DiffeoReg_i = 0
for a in range(len(anatomy_list)):
anatomy = anatomy_list[a]
# Input Paths
inputPath_i = subjFolderPath + "cmrep_" + anatomy + "/mesh/def3_target.vtk"
inputReader = vtk.vtkPolyDataReader()
inputReader.SetFileName(inputPath_i)
inputReader.Update()
input_i = inputReader.GetOutput()
# Estimated Paths
EGRegPath_i = EGRegFolderPath + "CMRep_EGReg_Recon_" + anatomy + "_Subjects_" + subj_i + "_t_" + str(
age_i) + ".vtk"
EGReg_reader = vtk.vtkPolyDataReader()
EGReg_reader.SetFileName(EGRegPath_i)
EGReg_reader.Update()
EGReg_est = EGReg_reader.GetOutput()
LRegPath_i = PC_LRegFolderPath + "Surface_ShapeWork_CTRL_Complex_" + anatomy + "_LinearModel_" + subj_i + "_" + str(
def run_script(args):
"""
Run the commandline script for MFSDA.
"""
"""+++++++++++++++++++++++++++++++++++"""
"""Step 1. load dataset """
print("loading data ......")
print("+++++++Read the surface shape data+++++++")
fh = open(args.shapeData, 'rU')
y_design = []
nshape = 0
numpoints = -1
header = fh.readline()
toks = header.split(sep=',')
covs_tmp = []
for line in fh.readlines():
toks = line.strip().split(sep=',')
# Read VTK file
vtkfilename = toks[0].rstrip()
print("Reading {}".format(vtkfilename))
reader = vtk.vtkPolyDataReader()
reader.SetFileName(vtkfilename)
reader.Update()
shapedata = reader.GetOutput()
shapedatapoints = shapedata.GetPoints()
y_design.append([])
if numpoints == -1:
numpoints = shapedatapoints.GetNumberOfPoints()
if numpoints != shapedatapoints.GetNumberOfPoints():
print(
"WARNING! The number of points is not the same for the shape:",
vtkfilename)
for i in range(shapedatapoints.GetNumberOfPoints()):
p = shapedatapoints.GetPoint(i)
y_design[nshape].append(p)
nshape += 1
# Build covariate matrix
covs_tmp.append(toks[1:])
y_design = np.array(y_design)
y_design.reshape(nshape, numpoints, 3)
y_design = np.array(y_design)
y_design.reshape(nshape, numpoints, 3)
print("The dimension of shape matrix is " + str(y_design.shape))
print("+++++++Read the sphere coordinate data+++++++")
print("Reading", args.coordData)
reader = vtk.vtkPolyDataReader()
reader.SetFileName(args.coordData)
reader.Update()
coordData = reader.GetOutput()
shapedatapoints = coordData.GetPoints()
if numpoints != shapedatapoints.GetNumberOfPoints():
print(
"WARNING! The template does not have the same number of points as the shapes"
)
coord_mat = []
for i in range(shapedatapoints.GetNumberOfPoints()):
p = shapedatapoints.GetPoint(i)
coord_mat.append(p)
coord_mat = np.array(coord_mat)
# Set up design matrix
design_data = np.array(covs_tmp, dtype=float)
# read the covariate type
var_type = getCovariateType(design_data)
"""+++++++++++++++++++++++++++++++++++"""
"""Step 2. Statistical analysis: including (1) smoothing and (2) hypothesis testing"""
gpvals, lpvals_fdr, clu_pvals, efit_beta, efity_design, efit_eta = mfsda.run_stats(
y_design, coord_mat, design_data, var_type)
"""+++++++++++++++++++++++++++++++++++"""
"""Step3. Save all the results"""
if not os.path.exists(args.outputDir):
os.makedirs(args.outputDir)
pvalues = {}
pvalues['Gpvals'] = gpvals.tolist()
pvalues['clu_pvals'] = clu_pvals.tolist()
pvalues['Lpvals_fdr'] = lpvals_fdr.tolist()
with open(os.path.join(args.outputDir, 'pvalues.json'), 'w') as outfile:
json.dump(pvalues, outfile)
efit = {}
efit['efitBetas'] = efit_beta.tolist()
efit['efitYdesign'] = efity_design.tolist()
efit['efitEtas'] = efit_eta.tolist()
with open(os.path.join(args.outputDir, 'efit.json'), 'w') as outfile:
json.dump(efit, outfile)
def readvtk(filename):
"""Read VTK file"""
reader = vtk.vtkPolyDataReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def SelectCuttingPlane(input_file):
## Get vtk format
file_format = input_file.split(".")[-1]
input_vtk = input_file.replace(file_format, "vtk")
if file_format == "nrrd":
print("\nCreating mesh from: " + input_file)
print("\nSaving as: " + input_vtk)
xml_filename = input_file.rsplit(os.sep,
1)[0] + "/cutting_plane_nrrd2vtk.xml"
create_meshfromDT_xml(xml_filename, input_file, input_vtk)
execCommand = ["MeshFromDistanceTransforms", xml_filename]
subprocess.check_call(execCommand)
print("Calling cmd:\n" + " ".join(execCommand))
elif file_format == "ply":
execCommand = ["ply2vtk", input_file, input_vtk]
subprocess.check_call(execCommand)
print("Calling cmd:\n" + " ".join(execCommand))
elif file_format == "stl":
execCommand = ["stl2vtk", input_file, input_vtk]
subprocess.check_call(execCommand)
print("Calling cmd:\n" + " ".join(execCommand))
elif file_format == "vtk":
pass
else:
print("Error, file format unrecognized: " + input_file)
## VTK interactive window
print(
'\n Use the interactive window to select your cutting plane. When you are content with your selection, simply close the window. \n'
)
# read data from file
# read data from file
reader = vtk.vtkPolyDataReader()
reader.SetFileName(input_vtk)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
# get data
data = reader.GetOutput()
(xmin, xmax, ymin, ymax, zmin, zmax) = data.GetBounds()
(xcenter, ycenter, zcenter) = data.GetCenter()
#create mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(data)
# The actor is a grouping mechanism
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# create camera
camera = vtk.vtkCamera()
camera.SetFocalPoint(xcenter, ycenter, zcenter)
camera.SetPosition(100, -300, -50)
camera.SetViewUp(0, 0, 1)
# create a renderer
renderer = vtk.vtkRenderer()
renderer.SetActiveCamera(camera)
renderer.SetBackground(0.2, 0.2, 0.5)
renderer.SetBackground2(0.4, 0.4, 1.0)
renderer.SetGradientBackground(True)
renderer.AddActor(actor)
# create a render_window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(1000, 1000)
# create a renderwindowiren
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(render_window)
iren.Initialize()
rep = vtk.vtkImplicitPlaneRepresentation()
rep.SetPlaceFactor(1.25)
rep.PlaceWidget(actor.GetBounds())
rep.SetNormal(0, 0, 1)
# Create a vtkImagePlaneWidget and activate it
plane_widget = vtk.vtkImplicitPlaneWidget2()
plane_widget.SetInteractor(iren)
plane_widget.SetRepresentation(rep)
plane_widget.On()
iren.Initialize()
iren.Start()
# use orgin as one point and use normla to solve for two others
(o1, o2, o3) = rep.GetOrigin()
(n1, n2, n3) = rep.GetNormal()
# using x = 1 and y =-1 solve for z
pt1_z = (-n1 + (n1 * o1) + n2 + (n2 * o2) + (n3 * o3)) / n3
# using x = -1 and y = 1 solve for z
pt2_z = (n1 + (n1 * o1) - n2 + (n2 * o2) + (n3 * o3)) / n3
# fix 0 edge case
if o1 == 0 and o2 == 0:
o1 = -1
o2 = -1
return np.array([[o1, o2, o3], [1, -1, pt1_z], [-1, 1, pt2_z]])
def show_allLandmarks(file_name, fixedLandmarks, curveLandmarks):
# input the curve landmarks in a list: curveLandmarks = [curve1, curve2]
#if you dont wish to input both fixed and curve landmarks you can
# place a [] as the input
#shows all the landmarks on the 3D model
import vtk
# from vtk.util.numpy_support import vtk_to_numpy
from dipy.viz import window
#import os
# Read the surface from file
if file_name[-3:] == 'vtk':
object = vtk.vtkPolyDataReader()
if file_name[-3:] == 'ply':
object = vtk.vtkPLYReader()
if file_name[-3:] == 'stl':
object = vtk.vtkSTLReader()
object.SetFileName(file_name)
objectMapper = vtk.vtkPolyDataMapper()
objectMapper.SetInputConnection(object.GetOutputPort())
objectMapper.ScalarVisibilityOff()
objectActor = vtk.vtkActor()
objectActor.SetMapper(objectMapper)
objectActor.GetProperty().SetColor(0.5, 0.5, 0.5)
renderer = window.Renderer()
renderer.add(objectActor)
def markcurve(x, y, z, landnum, curve, annotnum):
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((0, 0, 1))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(annotnum + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(textActor)
#add line
if landnum > 0:
lineSource = vtk.vtkLineSource()
lineSource.SetPoint1(curve[landnum - 1])
lineSource.SetPoint2([x, y, z])
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(lineSource.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(mapper)
lineActor.GetProperty().SetLineWidth(4)
lineActor.GetProperty().SetColor((0, 1, 0))
renderer.AddActor(lineActor)
show_m.iren.Render()
def markfixed(x, y, z, landnum):
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((1, 0, 0))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(landnum + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(textActor)
show_m.iren.Render()
show_m = window.ShowManager(renderer, size=(800, 800))
totalnum = 0
# if fixedLandmarks:
for lnum in range(len(fixedLandmarks)):
lm = fixedLandmarks[lnum]
markfixed(lm[0], lm[1], lm[2], totalnum)
totalnum += 1
for c in curveLandmarks:
for lnum in range(len(c)):
lm = c[lnum]
markcurve(lm[0], lm[1], lm[2], lnum, c, totalnum)
totalnum += 1
show_m.initialize()
show_m.render()
show_m.start()
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
fran = vtk.vtkPolyDataReader()
fran.SetFileName(fileName)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(fran.GetOutputPort())
normals.FlipNormalsOn()
franMapper = vtk.vtkPolyDataMapper()
franMapper.SetInputConnection(normals.GetOutputPort())
franActor = vtk.vtkActor()
franActor.SetMapper(franMapper)
franActor.GetProperty().SetColor(colors.GetColor3d("Flesh"))
# We subsample the dataset because we want to glyph just a subset of
# the points. Otherwise the display is cluttered and cannot be easily
# read. The RandomModeOn and SetOnRatio combine to random select one out
# of every 10 points in the dataset.
#
ptMask = vtk.vtkMaskPoints()
ptMask.SetInputConnection(normals.GetOutputPort())
ptMask.SetOnRatio(10)
ptMask.RandomModeOn()
# In this case we are using a cone as a glyph. We transform the cone so
# its base is at 0,0,0. This is the point where glyph rotation occurs.
cone = vtk.vtkConeSource()
cone.SetResolution(6)
transform = vtk.vtkTransform()
transform.Translate(0.5, 0.0, 0.0)
transformF = vtk.vtkTransformPolyDataFilter()
transformF.SetInputConnection(cone.GetOutputPort())
transformF.SetTransform(transform)
# vtkGlyph3D takes two inputs: the input point set (SetInputConnection)
# which can be any vtkDataSet and the glyph (SetSourceConnection) which
# must be a vtkPolyData. We are interested in orienting the glyphs by the
# surface normals that we previously generated.
glyph = vtk.vtkGlyph3D()
glyph.SetInputConnection(ptMask.GetOutputPort())
glyph.SetSourceConnection(transformF.GetOutputPort())
glyph.SetVectorModeToUseNormal()
glyph.SetScaleModeToScaleByVector()
glyph.SetScaleFactor(0.004)
spikeMapper = vtk.vtkPolyDataMapper()
spikeMapper.SetInputConnection(glyph.GetOutputPort())
spikeActor = vtk.vtkActor()
spikeActor.SetMapper(spikeMapper)
spikeActor.GetProperty().SetColor(colors.GetColor3d("Emerald_Green"))
# Create the RenderWindow, Renderer and Interactor.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(franActor)
ren1.AddActor(spikeActor)
renWin.SetSize(640, 480)
ren1.SetBackground(colors.GetColor3d("SlateGray"))
# Render the image.
#
renWin.Render()
ren1.GetActiveCamera().Zoom(1.4)
ren1.GetActiveCamera().Azimuth(110)
renWin.Render()
iren.Start()
def choose_curveLandmarks(file_name, fixedLandmarks=[]):
#Place curve landmarks
#can display fixed landmarks for aiding placement
import vtk
from dipy.viz import window
import numpy as np
#import os
# Read the surface from file
if file_name[-3:] == 'vtk':
object = vtk.vtkPolyDataReader()
if file_name[-3:] == 'ply':
object = vtk.vtkPLYReader()
if file_name[-3:] == 'stl':
object = vtk.vtkSTLReader()
object.SetFileName(file_name)
objectMapper = vtk.vtkPolyDataMapper()
objectMapper.SetInputConnection(object.GetOutputPort())
objectMapper.ScalarVisibilityOff()
objectActor = vtk.vtkActor()
objectActor.SetMapper(objectMapper)
objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) # grey
renderer = window.Renderer()
renderer.add(objectActor)
landmarks = []
actortextdict = {}
actorlinedict = {}
def mark(x, y, z):
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((0, 0, 1))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(len(landmarks) + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
actortextdict[marker] = textActor
renderer.AddActor(textActor)
#add line
if len(landmarks) > 0:
lineSource = vtk.vtkLineSource()
lineSource.SetPoint1(landmarks[-1])
lineSource.SetPoint2([x, y, z])
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(lineSource.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(mapper)
lineActor.GetProperty().SetLineWidth(4)
lineActor.GetProperty().SetColor((0, 1, 0))
actorlinedict[marker] = lineActor
renderer.AddActor(lineActor)
show_m.iren.Render()
def pick_cell(renwinInteractor, event):
x, y = renwinInteractor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
picker.AddPickList(objectActor)
picker.SetTolerance(0.01)
picker.Pick(x, y, 0, renderer)
points = picker.GetPickedPositions()
numPoints = points.GetNumberOfPoints()
if numPoints < 1: return
pnt = points.GetPoint(0)
mark(*pnt)
landmarks.append(pnt)
def remove_cell(renwinInteractor, event):
x, y = renwinInteractor.GetEventPosition()
picker = vtk.vtkPropPicker()
# picker.PickFromListOn()
# picker.AddPickList(objectActor)
# picker.SetTolerance(0.01)
picker.Pick(x, y, 0, renderer)
pickedActor = picker.GetActor()
if pickedActor:
if pickedActor != objectActor:
mapper = pickedActor.GetMapper()
inputs = mapper.GetInput()
point = inputs.GetCenter()
if point not in fixedLandmarks:
renderer.RemoveActor(pickedActor)
renderer.RemoveActor(actortextdict[pickedActor])
if len(landmarks) > 1:
renderer.RemoveActor(actorlinedict[pickedActor])
show_m.iren.Render()
if point in landmarks:
landmarks.remove(point)
def markfixed(x, y, z, landnum):
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((1, 0, 0))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(landnum + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(textActor)
show_m.iren.Render()
show_m = window.ShowManager(renderer, size=(800, 800))
show_m.iren.AddObserver('LeftButtonPressEvent', pick_cell)
show_m.iren.AddObserver('RightButtonPressEvent', remove_cell)
# if fixedLandmarks:
for lnum in range(len(fixedLandmarks)):
lm = fixedLandmarks[lnum]
markfixed(lm[0], lm[1], lm[2], lnum)
show_m.initialize()
show_m.render()
show_m.start()
return np.array(landmarks)
def choose_fixedLandmarks(file_name, template=[]):
#place fixed landmarks on 3D model
#left click to place, right click to remove
#can display a template for aiding placement
import vtk
from dipy.viz import window
import numpy as np
# import the 3D surface from file
if file_name[-3:] == 'vtk':
object = vtk.vtkPolyDataReader()
if file_name[-3:] == 'ply':
object = vtk.vtkPLYReader()
if file_name[-3:] == 'stl':
object = vtk.vtkSTLReader()
object.SetFileName(file_name)
objectMapper = vtk.vtkPolyDataMapper()
objectMapper.SetInputConnection(object.GetOutputPort())
objectMapper.ScalarVisibilityOff()
objectActor = vtk.vtkActor()
objectActor.SetMapper(objectMapper)
objectActor.GetProperty().SetColor(0.5, 0.5, 0.5) # grey
#left over from other work, don't delete yet
#objectActor.GetProperty().SetColor(.24, .70, .44) #mediumseagreen
#objectActor.GetProperty().SetColor(0.498039, 1, 0.831373) #springgreen
#objectActor.GetProperty().SetColor(color[0],color[1],color[2])
# Attach to a renderer
# ren = vtk.vtkRenderer()
# ren.AddActor(objectActor)
# ren.SetBackground(0.1, 0.1, 0.1)
# Attach to a window
# renWin = vtk.vtkRenderWindow()
# renWin.AddRenderer(ren)
# #renWin.SetWindowName("surface")
# renWin.SetSize(500,500)
# Attach to an interactor
# iren = vtk.vtkRenderWindowInteractor()
# iren.SetRenderWindow(renWin)
# style = vtk.vtkInteractorStyleSwitch()
# style.SetCurrentStyleToTrackballCamera()
# iren.SetInteractorStyle(style)
# iren.Initialize()
# iren.Start()
#
#
#create render window
renderer = window.Renderer()
#add 3D surface to window
renderer.add(objectActor)
#initialize landmarks
landmarks = []
#initialize dictionary for tying landmarks to annotations
actortextdict = {}
def mark(x, y, z):
#function for placing a landmark sphere
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((1, 0, 0))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(len(landmarks) + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
actortextdict[marker] = textActor
renderer.AddActor(textActor)
show_m.iren.Render()
def pick_cell(renwinInteractor, event):
#function for placing a landmark at mouse click position
x, y = renwinInteractor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
picker.AddPickList(objectActor)
picker.SetTolerance(0.01)
picker.Pick(x, y, 0, renderer)
points = picker.GetPickedPositions()
numPoints = points.GetNumberOfPoints()
if numPoints < 1: return
pnt = points.GetPoint(0)
mark(*pnt)
landmarks.append(pnt)
def remove_cell(renwinInteractor, event):
#function for removing a landmark at mouse click position
x, y = renwinInteractor.GetEventPosition()
picker = vtk.vtkPropPicker()
# picker.PickFromListOn()
# picker.AddPickList(objectActor)
# picker.SetTolerance(0.01)
picker.Pick(x, y, 0, renderer)
pickedActor = picker.GetActor()
if pickedActor:
if pickedActor != objectActor:
mapper = pickedActor.GetMapper()
inputs = mapper.GetInput()
point = inputs.GetCenter()
if point not in template:
renderer.RemoveActor(pickedActor)
renderer.RemoveActor(actortextdict[pickedActor])
show_m.iren.Render()
if point in landmarks:
landmarks.remove(point)
def marktemplate(x, y, z, landnum):
#function for placing template landmarks
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((1, 1, 0))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(landnum + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(textActor)
show_m.iren.Render()
show_m = window.ShowManager(renderer, size=(800, 800))
show_m.iren.AddObserver('LeftButtonPressEvent', pick_cell)
show_m.iren.AddObserver('RightButtonPressEvent', remove_cell)
tempnum = 0
for lnum in range(len(template)):
lm = template[lnum]
marktemplate(lm[0], lm[1], lm[2], tempnum)
tempnum += 1
show_m.initialize()
show_m.render()
show_m.start()
return np.array(landmarks)
def show_fixedLandmarks(file_name, landmarks):
#show the landmarks on the 3D model
import vtk
from dipy.viz import window
# Read the surface from file
if file_name[-3:] == 'vtk':
object = vtk.vtkPolyDataReader()
if file_name[-3:] == 'ply':
object = vtk.vtkPLYReader()
if file_name[-3:] == 'stl':
object = vtk.vtkSTLReader()
object.SetFileName(file_name)
objectMapper = vtk.vtkPolyDataMapper()
objectMapper.SetInputConnection(object.GetOutputPort())
objectMapper.ScalarVisibilityOff()
objectActor = vtk.vtkActor()
objectActor.SetMapper(objectMapper)
objectActor.GetProperty().SetColor(0.5, 0.5, 0.5)
renderer = window.Renderer()
renderer.add(objectActor)
def mark(x, y, z, landnum):
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1)
res = 20
sphere.SetThetaResolution(res)
sphere.SetPhiResolution(res)
sphere.SetCenter(x, y, z)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
marker = vtk.vtkActor()
marker.SetMapper(mapper)
renderer.AddActor(marker)
marker.GetProperty().SetColor((1, 0, 0))
#annotate the mark
atext = vtk.vtkVectorText()
atext.SetText(str(landnum + 1))
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(3, 3, 3)
textActor.AddPosition(x, y, z)
textActor.SetCamera(renderer.GetActiveCamera())
renderer.AddActor(textActor)
show_m.iren.Render()
show_m = window.ShowManager(renderer, size=(800, 800))
for lnum in range(len(landmarks)):
lm = landmarks[lnum]
mark(lm[0], lm[1], lm[2], lnum)
show_m.initialize()
show_m.render()
show_m.start()
def main(args):
inputSurface = args.surf
if args.n_rot > 1 and not os.path.exists(args.out):
os.mkdir(args.out)
path, extension = os.path.splitext(inputSurface)
extension = extension.lower()
if extension == ".vtk":
reader = vtk.vtkPolyDataReader()
reader.SetFileName(inputSurface)
reader.Update()
original_surf = reader.GetOutput()
elif extension == ".stl":
reader = vtk.vtkSTLReader()
reader.SetFileName(inputSurface)
reader.Update()
original_surf = reader.GetOutput()
if args.n_rot == 1:
rotated_surf = transform(original_surf, args.rot_v, args.angle)
outfilename = args.out
print("Writting:", outfilename)
polydatawriter = vtk.vtkPolyDataWriter()
polydatawriter.SetFileName(outfilename)
polydatawriter.SetInputData(rotated_surf)
polydatawriter.Write()
else:
for i in range(args.n_rot):
rotated_surf = transform(original_surf)
outfilename, ext = os.path.splitext(inputSurface)
outfilename = os.path.join(
args.out,
os.path.basename(outfilename)) + "_" + str(i) + ".vtk"
print("Writting:", outfilename)
polydatawriter = vtk.vtkPolyDataWriter()
polydatawriter.SetFileName(outfilename)
polydatawriter.SetInputData(rotated_surf)
polydatawriter.Write()
if (args.visualize):
mapper_orig = vtk.vtkPolyDataMapper()
mapper_orig.SetInputData(original_surf)
mapper_transform = vtk.vtkPolyDataMapper()
mapper_transform.SetInputData(rotated_surf)
actor1 = vtk.vtkActor()
actor1.SetMapper(mapper_orig)
actor2 = vtk.vtkActor()
actor2.SetMapper(mapper_transform)
colors = vtk.vtkNamedColors()
actor1.GetProperty().SetColor(colors.GetColor3d('Red'))
actor2.GetProperty().SetColor(colors.GetColor3d('Blue'))
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
WIDTH = 640
HEIGHT = 480
renWin.SetSize(WIDTH, HEIGHT)
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# assign actor to the renderer
ren.AddActor(actor1)
ren.AddActor(actor2)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
def readMeshFile(filename, clean=True, verbose=False, recompute_normals=True):
"""Read mesh file.
The input format is determined by file name extension.
Polygons get split into triangles to support various restrictive output
formats.
If clean, degenerate data gets removed."""
informat = path.splitext(options.infilename)[1].strip('.')
# set reader based on filename extension
if informat == 'stl':
reader = vtk.vtkSTLReader()
elif informat == 'vtk':
reader = vtk.vtkPolyDataReader()
elif informat == 'obj':
reader = vtk.vtkMNIObjectReader()
elif informat == 'ply':
reader = vtk.vtkPLYReader()
elif informat == 'vtp':
reader = vtk.vtkXMLPolyDataReader()
#elif informat=='tag':
# reader = vtk.vtkMNITagPointReader()
else:
raise ValueError('cannot read input format: ' + informat)
reader.SetFileName(filename)
reader.Update()
if verbose:
print("read %i polygons from file %s" % \
(reader.GetOutput().GetNumberOfPolys(), filename))
# merge duplicate points, and/or remove unused points and/or remove degenerate cells
if clean:
polydata = vtk.vtkCleanPolyData()
polydata.SetInputConnection(reader.GetOutputPort())
poly_data_algo = polydata
if verbose:
print("cleaned poly data")
else:
poly_data_algo = reader
# convert input polygons and strips to triangles
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(poly_data_algo.GetOutputPort())
if recompute_normals:
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(triangles.GetOutputPort())
normals.SplittingOff()
normals.ComputePointNormalsOn()
normals.AutoOrientNormalsOn()
normals.ConsistencyOn()
normals.NonManifoldTraversalOn()
if verbose:
print("recomputed normals")
print("finished reading", filename)
return normals
else:
if verbose:
print("finished reading", filename)
return triangles
def test_airway_particles():
# Get the path to the this test so that we can reference the test data
this_dir = os.path.dirname(os.path.realpath(__file__))
# Set up the inputs to AirwayParticles
input_ct = this_dir + '/../../../Testing/Data/Input/airway.nrrd'
output_particles = this_dir + '/../../../Testing/tmp/airway_particles.vtk'
tmp_dir = this_dir + '/../../../Testing/tmp/'
input_mask = None
max_scale = 6.0
live_th = 50.0
seed_th = 40.0
scale_samples = 5
down_sample_rate = 1.0
min_intensity = -1100
max_intensity = -400
# Generate the airway particles
ap = AirwayParticles(input_ct, output_particles, tmp_dir, input_mask,
max_scale, live_th, seed_th, scale_samples,
down_sample_rate, min_intensity, max_intensity)
ap.execute()
# Read in the reference data set for comparison
ref_reader = vtk.vtkPolyDataReader()
ref_reader.SetFileName(this_dir +
'/../../../Testing/Data/Input/airway_particles.vtk')
ref_reader.Update()
# Now read in the output data set
test_reader = vtk.vtkPolyDataReader()
test_reader.SetFileName(
this_dir + '/../../../Testing/Data/Input/airway_particles.vtk')
test_reader.Update()
# The test passes provided that every particle in the reference data set
# has a partner within an '_irad' distance of some particle in the test
# data set and vice versa
irad = ap._irad
for i in xrange(0, ref_reader.GetOutput().GetNumberOfPoints()):
ref_point = np.array(ref_reader.GetOutput().GetPoint(i))
test_pass = False
for j in xrange(0, test_reader.GetOutput().GetNumberOfPoints()):
test_point = np.array(test_reader.GetOutput().GetPoint(j))
dist = sqrt(sum((ref_point - test_point)**2))
if dist <= irad:
test_pass = True
break
assert test_pass, 'Airway particle has no match'
for i in xrange(0, test_reader.GetOutput().GetNumberOfPoints()):
test_point = np.array(test_reader.GetOutput().GetPoint(i))
test_pass = False
for j in xrange(0, ref_reader.GetOutput().GetNumberOfPoints()):
ref_point = np.array(ref_reader.GetOutput().GetPoint(j))
dist = sqrt(sum((ref_point - test_point)**2))
if dist <= irad:
test_pass = True
break
assert test_pass, 'Airway particle has no match'
# Clean up the tmp directory. Note that this block should probably change
# if this test is altered
files = [
'V-000-005.nrrd', 'V-001-005.nrrd', 'V-002-005.nrrd', 'V-003-005.nrrd',
'V-004-005.nrrd', 'airway_particles.vtk', 'ct-deconv.nrrd',
'hess.nrrd', 'heval0.nrrd', 'heval1.nrrd', 'heval2.nrrd',
'hevec0.nrrd', 'hevec1.nrrd', 'hevec2.nrrd', 'hmode.nrrd',
'pass1.nrrd', 'pass2.nrrd', 'pass3.nrrd', 'val.nrrd', '2dd.nrrd',
'curvdir1.nrrd', 'curvdir2.nrrd', 'flowlinecurv.nrrd',
'gausscurv.nrrd', 'gmag.nrrd', 'gvec.nrrd', 'hf.nrrd', 'kappa1.nrrd',
'kappa2.nrrd', 'lapl.nrrd', 'meancurv.nrrd', 'median.nrrd', 'si.nrrd',
'st.nrrd', 'totalcurv.nrrd'
]
for f in files:
if os.path.isfile(tmp_dir + f):
subprocess.call("rm " + tmp_dir + f, shell=True)
def main():
file_name, color_scheme = get_program_parameters()
color_scheme = abs(color_scheme)
if color_scheme > 2:
color_scheme = 0;
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor", [26, 51, 102, 255])
# Read a vtk file
#
hawaii = vtk.vtkPolyDataReader()
hawaii.SetFileName(file_name)
hawaii.Update()
bounds = [0.0] * 6
hawaii.GetOutput().GetBounds(bounds)
elevation = vtk.vtkElevationFilter()
elevation.SetInputConnection(hawaii.GetOutputPort())
elevation.SetLowPoint(0, 0, 0)
elevation.SetHighPoint(0, 0, 1000)
elevation.SetScalarRange(0, 1000)
lut = MakeLUT(color_scheme)
hawaiiMapper = vtk.vtkDataSetMapper()
hawaiiMapper.SetInputConnection(elevation.GetOutputPort())
hawaiiMapper.SetScalarRange(0, 1000)
hawaiiMapper.ScalarVisibilityOn()
hawaiiMapper.SetLookupTable(lut)
hawaiiActor = vtk.vtkActor()
hawaiiActor.SetMapper(hawaiiMapper)
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(hawaiiActor)
# Match the window shape to the object.
# renWin.SetSize(500, int(500 * bounds[1] / bounds[3]))
renWin.SetSize(500, 500)
iren.Initialize()
# Render the image.
# Centered on Honolulu.
# Diamond Head is the crater lower left.
# Punchbowl is the crater in the centre.
renWin.Render()
ren.SetBackground(colors.GetColor3d("BkgColor"))
ren.GetActiveCamera().Zoom(1.5)
ren.GetActiveCamera().Roll(-90)
renWin.Render()
iren.Start()
def read_polydata(filename, datatype=None):
"""
Load the given file, and return a vtkPolyData object for it.
Args:
filename (str): Path to input file.
datatype (str): Additional parameter for vtkIdList objects.
Returns:
polyData (vtkSTL/vtkPolyData/vtkXMLStructured/
vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
vtkXMLImage/Tecplot): Output data.
"""
# Check if file exists
if not path.exists(filename):
raise RuntimeError("Could not find file: %s" % filename)
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise RuntimeError('The file does not have an extension')
# Get reader
if fileType == 'stl':
reader = vtk.vtkSTLReader()
reader.MergingOn()
elif fileType == 'vtk':
# Read header
with open(filename, "rb") as f:
head = list(islice(f, 10))
head = "".join([l.decode('utf-8', 'backslashreplace')
for l in head]).lower()
# Set reader based on header
if "unstructured_grid" in head:
reader = vtk.vtkUnstructuredGridReader()
elif "structured_grid" in head:
reader = vtk.vtkStructuredGridReader()
elif "rectilinear_grid" in head:
reader = vtk.vtkRectilinearGridReader()
elif "structured_points" in head:
reader = vtk.vtkStructuredPointsReader()
elif "polydata" in head:
reader = vtk.vtkPolyDataReader()
elif fileType == 'vtp':
reader = vtk.vtkXMLPolyDataReader()
elif fileType == 'vts':
reader = vtk.vtkXMLStructuredGridReader()
elif fileType == 'vtr':
reader = vtk.vtkXMLRectilinearGridReader()
elif fileType == 'vtu':
reader = vtk.vtkXMLUnstructuredGridReader()
elif fileType == "vti":
reader = vtk.vtkXMLImageDataReader()
elif fileType == "np" and datatype == "vtkIdList":
result = np.load(filename).astype(np.int)
id_list = vtk.vtkIdList()
id_list.SetNumberOfIds(result.shape[0])
for i in range(result.shape[0]):
id_list.SetId(i, result[i])
return id_list
else:
raise RuntimeError('Unknown file type %s' % fileType)
# Read
reader.SetFileName(filename)
reader.Update()
polydata = reader.GetOutput()
return polydata
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
# Create lines which serve as the 'seed' geometry. The lines spell the
# word 'hello'.
#
reader = vtk.vtkPolyDataReader()
reader.SetFileName(fileName)
lineMapper = vtk.vtkPolyDataMapper()
lineMapper.SetInputConnection(reader.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
lineActor.GetProperty().SetColor(colors.GetColor3d('Tomato'))
lineActor.GetProperty().SetLineWidth(3.0)
# Create implicit model with vtkImplicitModeller. This computes a scalar
# field which is the distance from the generating geometry. The contour
# filter then extracts the geometry at the distance value 0.25 from the
# generating geometry.
#
imp = vtk.vtkImplicitModeller()
imp.SetInputConnection(reader.GetOutputPort())
imp.SetSampleDimensions(110, 40, 20)
imp.SetMaximumDistance(0.25)
imp.SetModelBounds(-1.0, 10.0, -1.0, 3.0, -1.0, 1.0)
contour = vtk.vtkContourFilter()
contour.SetInputConnection(imp.GetOutputPort())
contour.SetValue(0, 0.25)
impMapper = vtk.vtkPolyDataMapper()
impMapper.SetInputConnection(contour.GetOutputPort())
impMapper.ScalarVisibilityOff()
impActor = vtk.vtkActor()
impActor.SetMapper(impMapper)
impActor.GetProperty().SetColor(colors.GetColor3d('Peacock'))
impActor.GetProperty().SetOpacity(0.5)
# Create the usual graphics stuff.
# Create the RenderWindow, Renderer and Interactor.
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.SetWindowName('Hello')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(lineActor)
ren1.AddActor(impActor)
ren1.SetBackground(colors.GetColor3d('Wheat'))
renWin.SetSize(640, 480)
camera = vtk.vtkCamera()
camera.SetFocalPoint(4.5, 1, 0)
camera.SetPosition(4.5, 1.0, 6.73257)
camera.SetViewUp(0, 1, 0)
ren1.SetActiveCamera(camera)
ren1.ResetCamera()
camera.Dolly(1.3)
camera.SetClippingRange(1.81325, 90.6627)
renWin.Render()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
fileName1, fileName2, fileName3 = get_program_parameters()
aRenderer = vtk.vtkRenderer()
aRenderWindow = vtk.vtkRenderWindow()
aRenderWindow.AddRenderer(aRenderer)
anInteractor = vtk.vtkRenderWindowInteractor()
anInteractor.SetRenderWindow(aRenderWindow)
aRenderWindow.SetSize(300, 300)
aRenderWindow.SetWindowName('BlobbyLogo')
# Read the geometry file containing the letter v.
letterV = vtk.vtkPolyDataReader()
letterV.SetFileName(fileName1)
# Read the geometry file containing the letter t.
letterT = vtk.vtkPolyDataReader()
letterT.SetFileName(fileName2)
# Read the geometry file containing the letter k.
letterK = vtk.vtkPolyDataReader()
letterK.SetFileName(fileName3)
# Create a transform and transform filter for each letter.
VTransform = vtk.vtkTransform()
VTransformFilter = vtk.vtkTransformPolyDataFilter()
VTransformFilter.SetInputConnection(letterV.GetOutputPort())
VTransformFilter.SetTransform(VTransform)
TTransform = vtk.vtkTransform()
TTransformFilter = vtk.vtkTransformPolyDataFilter()
TTransformFilter.SetInputConnection(letterT.GetOutputPort())
TTransformFilter.SetTransform(TTransform)
KTransform = vtk.vtkTransform()
KTransformFilter = vtk.vtkTransformPolyDataFilter()
KTransformFilter.SetInputConnection(letterK.GetOutputPort())
KTransformFilter.SetTransform(KTransform)
# Now append them all.
appendAll = vtk.vtkAppendPolyData()
appendAll.AddInputConnection(VTransformFilter.GetOutputPort())
appendAll.AddInputConnection(TTransformFilter.GetOutputPort())
appendAll.AddInputConnection(KTransformFilter.GetOutputPort())
# Create normals.
logoNormals = vtk.vtkPolyDataNormals()
logoNormals.SetInputConnection(appendAll.GetOutputPort())
logoNormals.SetFeatureAngle(60)
# Map to rendering primitives.
logoMapper = vtk.vtkPolyDataMapper()
logoMapper.SetInputConnection(logoNormals.GetOutputPort())
# Now an actor.
logo = vtk.vtkActor()
logo.SetMapper(logoMapper)
# Now create an implicit model of the same letter.
blobbyLogoImp = vtk.vtkImplicitModeller()
blobbyLogoImp.SetInputConnection(appendAll.GetOutputPort())
blobbyLogoImp.SetMaximumDistance(.075)
blobbyLogoImp.SetSampleDimensions(64, 64, 64)
blobbyLogoImp.SetAdjustDistance(0.05)
# Extract an iso surface.
blobbyLogoIso = vtk.vtkContourFilter()
blobbyLogoIso.SetInputConnection(blobbyLogoImp.GetOutputPort())
blobbyLogoIso.SetValue(1, 1.5)
# Map to rendering primitives.
blobbyLogoMapper = vtk.vtkPolyDataMapper()
blobbyLogoMapper.SetInputConnection(blobbyLogoIso.GetOutputPort())
blobbyLogoMapper.ScalarVisibilityOff()
tomato = vtk.vtkProperty()
tomato.SetDiffuseColor(colors.GetColor3d('tomato'))
tomato.SetSpecular(.3)
tomato.SetSpecularPower(20)
banana = vtk.vtkProperty()
banana.SetDiffuseColor(colors.GetColor3d('banana'))
banana.SetDiffuse(.7)
banana.SetSpecular(.4)
banana.SetSpecularPower(20)
# Now an actor.
blobbyLogo = vtk.vtkActor()
blobbyLogo.SetMapper(blobbyLogoMapper)
blobbyLogo.SetProperty(banana)
# Position the letters.
VTransform.Translate(-16.0, 0.0, 12.5)
VTransform.RotateY(40)
KTransform.Translate(14.0, 0.0, 0.0)
KTransform.RotateY(-40)
# Move the polygonal letters to the front.
logo.SetProperty(tomato)
logo.SetPosition(0, 0, 6)
aRenderer.AddActor(logo)
aRenderer.AddActor(blobbyLogo)
aRenderer.SetBackground(colors.GetColor3d('SlateGray'))
aRenderWindow.Render()
# Interact with the data.
anInteractor.Start()
def volumetric_spline_augmentation(file, save_name='', save_points=0):
#file = '0212.vtk'
file_name = 'C:/Users/lowes/OneDrive/Skrivebord/DTU/6_Semester/Bachelor/LAA_segmentation/' + file
path = 'C:/Users/lowes/OneDrive/Skrivebord/DTU/6_Semester/Bachelor/Augmented_data/'
out_name = path + file.split('.')[0] + 'aug' + save_name + '.vtk'
pd_in = vtk.vtkPolyDataReader()
pd_in.SetFileName(file_name)
pd_in.Update()
pd = pd_in.GetOutput()
# Get bounding box
bounds = pd.GetBounds()
x_min = bounds[0]
x_max = bounds[1]
y_min = bounds[2]
y_max = bounds[3]
z_min = bounds[4]
z_max = bounds[5]
# get a measure of scale as the diagonal length
scale = math.sqrt((x_max - x_min) * (x_max - x_min) + (y_max - y_min) *
(y_max - y_min) + (z_max - z_min) * (z_max - z_min))
# Reference points
# Here just corners of the bounding box
# TODO: make more points
n = 3
i = 0
p1 = vtk.vtkPoints()
p1.SetNumberOfPoints(n * n * n)
xlin = np.linspace(x_min, x_max, n)
ylin = np.linspace(y_min, y_max, n)
zlin = np.linspace(z_min, z_max, n)
for x in xlin:
for y in ylin:
for z in zlin:
p1.SetPoint(i, x, y, z)
i += 1
'''
p1.SetPoint(0, x_min, y_min, z_min)
p1.SetPoint(1, x_max, y_min, z_min)
p1.SetPoint(2, x_min, y_max, z_min)
p1.SetPoint(3, x_max, y_max, z_min)
p1.SetPoint(4, x_min, y_min, z_max)
p1.SetPoint(5, x_max, y_min, z_max)
p1.SetPoint(6, x_min, y_max, z_max)
p1.SetPoint(7, x_max, y_max, z_max)
'''
# Deformed points
p2 = vtk.vtkPoints()
# Start by copying all info from p1
p2.DeepCopy(p1)
# Displace the points in a random direction
displacement_length = scale * 0.05 #change parameter around a bit
for i in range(p2.GetNumberOfPoints()):
p = list(p2.GetPoint(i))
for j in range(3):
p[j] = p[j] + (2.0 * random() - 1) * displacement_length
p2.SetPoint(i, p)
transform = vtk.vtkThinPlateSplineTransform()
transform.SetSourceLandmarks(p1)
transform.SetTargetLandmarks(p2)
transform.SetBasisToR2LogR()
transform.Update()
transform_filter = vtk.vtkTransformPolyDataFilter()
transform_filter.SetTransform(transform)
transform_filter.SetInputData(pd)
transform_filter.Update()
vs = np.array(transform_filter.GetOutput().GetPoints().GetData())
face_labels = np.array(
transform_filter.GetOutput().GetCellData().GetScalars())
poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons
faces = np.reshape(poly, (-1, 4))[:, 1:4]
print('writing file')
#vcolor = []
with open(out_name, 'w+') as f:
f.write(
"# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n"
% len(vs))
for vi, v in enumerate(vs):
#vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else ''
f.write("%f %f %f\n" % (v[0], v[1], v[2]))
f.write("POLYGONS %d %d \n" % (len(faces), 4 * len(faces)))
for face_id in range(len(faces) - 1):
f.write("3 %d %d %d\n" %
(faces[face_id][0], faces[face_id][1], faces[face_id][2]))
f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2]))
f.write(
"\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default"
% len(faces))
for j, face in enumerate(faces):
if j % 9 == 0:
f.write("\n")
f.write("%d " % face_labels[j])
print('done writing')
if save_points:
fig = plt.figure()
ax = fig.add_subplot(projection='3d')
points = np.asarray(p1.GetData())
ax.scatter(points[:, 0], points[:, 1], points[:, 2], linewidth=8)
#plt.show()
#fig = plt.figure()
#ax = fig.add_subplot(projection='3d')
points = np.asarray(p2.GetData())
ax.scatter(points[:, 0],
points[:, 1],
points[:, 2],
linewidth=8,
marker='x')
plt.show()
vs1 = np.array(p1.GetData())
out_p1 = path + file.split('.')[0] + '_p1.vtk'
with open(out_p1, 'w+') as f:
f.write(
"# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n"
% len(vs1))
for vi, v in enumerate(vs1):
f.write("%f %f %f\n" % (v[0], v[1], v[2]))
vs = np.array(p1.GetData())
vs2 = np.array(p2.GetData())
out_p2 = path + file.split('.')[0] + '_p2.vtk'
with open(out_p2, 'w+') as f:
f.write(
"# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n"
% len(vs2))
for vi, v in enumerate(vs2):
f.write("%f %f %f\n" % (v[0], v[1], v[2]))
'''
def buildATPMesh():
# Report our CWD just for testing purposes.
print("CWD:", os.getcwd())
# Read in the mesh.
print("Reading", meshFile)
meshReader = vtk.vtkXMLPolyDataReader()
meshReader.SetFileName(meshFile)
meshReader.Update()
ecMesh = meshReader.GetOutput()
# Read in the centreline.
print("Reading", centrelineFile)
centrelineReader = vtk.vtkPolyDataReader()
centrelineReader.SetFileName(centrelineFile)
centrelineReader.Update()
centreline = centrelineReader.GetOutput()
origin = centreline.GetPoint(0)
print("Origin:", origin)
# Put the ecMesh through centroids filter.
centroidFilter = vtk.vtkCellCenters()
centroidFilter.SetInputData(ecMesh)
centroidFilter.Update()
centroids = centroidFilter.GetOutput()
# Iterate over each centroid and find the closest segment
centroidPoints = centroids.GetPoints()
# Only for DEBUG output.
distArray = vtk.vtkDoubleArray()
distArray.SetName("Dist")
# For each point calculate the distance from origin.
totalPoints = centroidPoints.GetNumberOfPoints()
for ptId in range(totalPoints):
distance = vtk.vtkMath.Distance2BetweenPoints(
origin, centroidPoints.GetPoint(ptId))
distArray.InsertNextValue(math.sqrt(distance))
# Get the range of the distance values.
inMin, inMax = distArray.GetRange()
atpArray = vtk.vtkFloatArray()
atpArray.SetName('initialATP')
# Normalise distance values.
for i in range(distArray.GetNumberOfTuples()):
dist = distArray.GetTuple(i)[0]
distRescaled = rescale(dist, inMin, inMax)
atpVal = sigmoidATP(distRescaled)
atpArray.InsertNextValue(atpVal)
# Prepare debug ATP mesh.
debugAtpDataset = ecMesh
debugAtpDataset.GetCellData().AddArray(distArray)
debugAtpDataset.GetCellData().AddArray(atpArray)
# Save the debug ATP mesh.
debugAtpMapWriter = vtk.vtkXMLPolyDataWriter()
debugAtpMapWriter.SetFileName(debugAtpFile)
debugAtpMapWriter.SetInputData(debugAtpDataset)
debugAtpMapWriter.Update()
# Prepare the ATP mesh by converting all points to vercices.
pointsToVerticesFilter = vtk.vtkVertexGlyphFilter()
pointsToVerticesFilter.SetInputData(centroids)
pointsToVerticesFilter.Update()
atpDataset = pointsToVerticesFilter.GetOutput()
atpDataset.GetCellData().AddArray(atpArray)
# Assert the number of cells is equal to the number of items in the cell arrays.
assert atpArray.GetNumberOfTuples() == debugAtpDataset.GetNumberOfCells(
), "Number of cells (%d) and cell data values (%d) mismatch." % (
atpArray.GetNumberOfTuples(), debugAtpDataset.GetNumberOfCells())
atpMapWriter = vtk.vtkXMLPolyDataWriter()
atpMapWriter.SetFileName(atpFile)
atpMapWriter.SetInputData(atpDataset)
atpMapWriter.Update()
# Provide a quick visualisation of the ATP profile for validation.
pointsX = numpy.arange(outMin, outMax, 0.001)
pointsY = []
for pt in pointsX:
pointsY.append(sigmoidATP(pt))
pyplot.plot(pointsX, pointsY, 'b')
pyplot.show()
def main():
colors = vtk.vtkNamedColors()
fileName1, fileName2 = get_program_parameters()
# This example shows how to use decimation to reduce a polygonal mesh. We also
# use mesh smoothing and generate surface normals to give a pleasing result.
#
# We start by reading some data that was originally captured from
# a Cyberware laser digitizing system.
#
fran = vtk.vtkPolyDataReader()
fran.SetFileName(fileName1)
# Read the corresponding texture.
textureReader = vtk.vtkPNGReader()
textureReader.SetFileName(fileName2)
texture = vtk.vtkTexture()
texture.InterpolateOn()
texture.SetInputConnection(textureReader.GetOutputPort())
# We want to preserve topology (not let any cracks form). This may limit
# the total reduction possible, which we have specified at 90%.
#
deci = vtk.vtkDecimatePro()
deci.SetInputConnection(fran.GetOutputPort())
deci.SetTargetReduction(0.9)
deci.PreserveTopologyOn()
decimatedNormals = vtk.vtkPolyDataNormals()
decimatedNormals.SetInputConnection(deci.GetOutputPort())
decimatedNormals.FlipNormalsOn()
decimatedNormals.SetFeatureAngle(60)
originalNormals = vtk.vtkPolyDataNormals()
originalNormals.SetInputConnection(fran.GetOutputPort())
originalNormals.FlipNormalsOn()
originalNormals.SetFeatureAngle(60)
decimatedMapper = vtk.vtkPolyDataMapper()
decimatedMapper.SetInputConnection(decimatedNormals.GetOutputPort())
decimatedActor = vtk.vtkActor()
decimatedActor.SetMapper(decimatedMapper)
decimatedActor.GetProperty().SetAmbient(.5)
decimatedActor.GetProperty().SetDiffuse(.5)
decimatedActor.SetTexture(texture)
originalMapper = vtk.vtkPolyDataMapper()
originalMapper.SetInputConnection(originalNormals.GetOutputPort())
originalActor = vtk.vtkActor()
originalActor.SetMapper(originalMapper)
originalActor.GetProperty().SetAmbient(.5)
originalActor.GetProperty().SetDiffuse(.5)
originalActor.SetTexture(texture)
# Create the RenderWindow, Renderer and Interactor.
#
renderer1 = vtk.vtkRenderer()
renderer1.SetViewport(0., 0.0, 0.5, 1.0)
renderer2 = vtk.vtkRenderer()
renderer2.SetViewport(0.5, 0.0, 1.0, 1.0)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer1)
renderWindow.AddRenderer(renderer2)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Add the actors to the renderer, set the background and size.
#
renderer1.AddActor(originalActor)
renderer2.AddActor(decimatedActor)
renderer1.SetBackground(colors.GetColor3d("Wheat"))
renderer2.SetBackground(colors.GetColor3d("Papaya_Whip"))
renderWindow.SetSize(800, 400)
# Render the image.
#
cam1 = vtk.vtkCamera()
cam1.SetClippingRange(0.0475572, 2.37786)
cam1.SetFocalPoint(0.052665, -0.129454, -0.0573973)
cam1.SetPosition(0.327637, -0.116299, -0.256418)
cam1.SetViewUp(-0.0225386, 0.999137, 0.034901)
renderer1.SetActiveCamera(cam1)
renderer2.SetActiveCamera(cam1)
renderWindow.Render()
interactor.Start()
def convert(input, config=None, verbose=True, coords_only=False):
extension = os.path.splitext(input)[1].lower()
if extension == '.vtp':
r = vtk.vtkXMLPolyDataReader()
r.SetFileName(input)
r.Update()
polydata = r.GetOutput()
elif extension == '.vtk':
r = vtk.vtkPolyDataReader()
r.SetFileName(input)
r.Update()
polydata = r.GetOutput()
else:
raise Error('Invalid input format.')
# print(polydata.GetBounds())
points = numpy_support.vtk_to_numpy(polydata.GetPoints().GetData())
lines = numpy_support.vtk_to_numpy(polydata.GetLines().GetData())
number_of_streamlines = polydata.GetLines().GetNumberOfCells()
#
# scalars are per point
#
pointdata = polydata.GetPointData()
number_of_scalars = pointdata.GetNumberOfArrays()
scalars = []
scalar_types = []
scalar_names = []
if not coords_only:
for i in range(number_of_scalars):
arr_name = pointdata.GetArrayName(i)
scalar_names.append(str(arr_name))
arr = pointdata.GetArray(i)
# arr.ComputeScalarRange()
# print(arr)
number_of_components = arr.GetNumberOfComponents()
data_type = arr.GetDataType()
scalar_types.append((data_type, number_of_components))
if verbose:
print('Loading scalar', arr_name)
scalars.append(numpy_support.vtk_to_numpy(arr))
#
# properties are per streamline
#
celldata = polydata.GetCellData()
number_of_properties = celldata.GetNumberOfArrays()
properties = []
property_types = []
property_names = []
if not coords_only:
for i in range(number_of_properties):
arr_name = celldata.GetArrayName(i)
property_names.append(str(arr_name))
arr = celldata.GetArray(i)
# print(i, arr)
number_of_components = arr.GetNumberOfComponents()
data_type = arr.GetDataType()
property_types.append((data_type, number_of_components))
if verbose:
print('Loading property', arr_name)
properties.append(numpy_support.vtk_to_numpy(arr))
#
# convert to streamlines
#
ordered_indices = []
ordered_scalars = []
i = 0
current_fiber_id = 0
line_length = 0
# sanity check
if len(lines) > 0:
line_length = lines[i]
line_index = 0
lines_just_length = []
while (line_index < number_of_streamlines):
lines_just_length.append(line_length)
current_line = lines[i + 1 + line_index:i + 1 + line_length +
line_index]
current_indices = []
# print('line',line_index)
for k in range(len(current_line) - 1):
indexA = current_line[k]
indexB = current_line[k + 1]
# print(indexA, indexB)
current_indices.append(indexA)
current_indices.append(indexB)
ordered_indices += current_indices
i += line_length
line_index += 1
if line_index < number_of_streamlines:
line_length = lines[i + line_index]
#
# now, create fiber cluster data structure
#
fibercluster = {
'number_of_streamlines': number_of_streamlines,
'per_vertex_data': collections.OrderedDict(),
'indices': lines_just_length, #ordered_indices
'per_streamline_data': collections.OrderedDict()
}
fibercluster['per_vertex_data']['POSITION'] = {
'componentType':
vtkDataType_to_gltfComponentType[polydata.GetPoints().GetDataType()],
'type':
vtkNumberOfComponents_to_gltfType[
polydata.GetPoints().GetData().GetNumberOfComponents()],
'data':
points #ordered_vertices
}
for i, s in enumerate(scalar_names):
vtkdatatype = scalar_types[i][0]
vtknumberofcomponents = scalar_types[i][1]
thisdata = scalars[i] #[]
if vtknumberofcomponents in vtkNumberOfComponents_to_gltfType:
gltfType = vtkNumberOfComponents_to_gltfType[vtknumberofcomponents]
else:
# for now, we will just pass it through
gltfType = vtknumberofcomponents
fibercluster['per_vertex_data'][s] = {
'componentType': vtkDataType_to_gltfComponentType[vtkdatatype],
'type': gltfType,
'data': thisdata
}
for i, p in enumerate(property_names):
vtkdatatype = property_types[i][0]
vtknumberofcomponents = property_types[i][1]
thisdata = properties[i] #[]
if vtknumberofcomponents in vtkNumberOfComponents_to_gltfType:
gltfType = vtkNumberOfComponents_to_gltfType[vtknumberofcomponents]
else:
# for now, we will just pass it through
gltfType = vtknumberofcomponents
fibercluster['per_streamline_data'][p] = {
'componentType': vtkDataType_to_gltfComponentType[vtkdatatype],
'type': gltfType,
'data': thisdata
}
return fibercluster
def volumetric_spline_augmentation():
out_name = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079aug.vtk'
file_name = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/LAA_segmentation/0079.vtk'
out_name_grid = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079_grid.vtk'
out_name_grid_warped = 'C:/Users/lakri/Documents/BachelorProjekt/Spares MeshCNN/MeshCNN_sparse/datasets/DataAug/0079_grid_warped.vtk'
pd_in = vtk.vtkPolyDataReader()
pd_in.SetFileName(file_name)
pd_in.Update()
pd = pd_in.GetOutput()
grid_3d = create_3d_grid(pd)
print('writing grid')
writer = vtk.vtkPolyDataWriter()
writer.SetFileName(out_name_grid)
writer.SetInputData(grid_3d)
writer.Write()
print('done writing')
# Get bounding box
bounds = pd.GetBounds()
x_min = bounds[0]
x_max = bounds[1]
y_min = bounds[2]
y_max = bounds[3]
z_min = bounds[4]
z_max = bounds[5]
# get a measure of scale as the diagonal length
scale = math.sqrt((x_max - x_min) * (x_max - x_min) + (y_max - y_min) *
(y_max - y_min) + (z_max - z_min) * (z_max - z_min))
# Reference points
# Here just corners of the bounding box
# TODO: make more points
n = 8
i = 0
p1 = vtk.vtkPoints()
p1.SetNumberOfPoints(n * n * n)
xlin = np.linspace(x_min, x_max, n)
ylin = np.linspace(y_min, y_max, n)
zlin = np.linspace(z_min, z_max, n)
for x in xlin:
for y in ylin:
for z in zlin:
p1.SetPoint(i, x, y, z)
i += 1
'''
p1.SetPoint(0, x_min, y_min, z_min)
p1.SetPoint(1, x_max, y_min, z_min)
p1.SetPoint(2, x_min, y_max, z_min)
p1.SetPoint(3, x_max, y_max, z_min)
p1.SetPoint(4, x_min, y_min, z_max)
p1.SetPoint(5, x_max, y_min, z_max)
p1.SetPoint(6, x_min, y_max, z_max)
p1.SetPoint(7, x_max, y_max, z_max)
'''
# Deformed points
p2 = vtk.vtkPoints()
# Start by copying all info from p1
p2.DeepCopy(p1)
# Displace the points in a random direction
displacement_length = scale * 0.03 #change parameter around a bit
for i in range(p2.GetNumberOfPoints()):
p = list(p2.GetPoint(i))
for j in range(3):
p[j] = p[j] + (2.0 * random() - 1) * displacement_length
p2.SetPoint(i, p)
transform = vtk.vtkThinPlateSplineTransform()
transform.SetSourceLandmarks(p1)
transform.SetTargetLandmarks(p2)
transform.SetBasisToR2LogR()
transform.Update()
transform_filter = vtk.vtkTransformPolyDataFilter()
transform_filter.SetTransform(transform)
transform_filter.SetInputData(pd)
transform_filter.Update()
vs = np.array(transform_filter.GetOutput().GetPoints().GetData())
face_labels = np.array(
transform_filter.GetOutput().GetCellData().GetScalars())
poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons
faces = np.reshape(poly, (-1, 4))[:, 1:4]
#vcolor = []
print('writing aug mesh')
with open(out_name, 'w+') as f:
f.write(
"# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n"
% len(vs))
for vi, v in enumerate(vs):
#vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else ''
f.write("%f %f %f\n" % (v[0], v[1], v[2]))
f.write("POLYGONS %d %d \n" % (len(faces), 4 * len(faces)))
for face_id in range(len(faces) - 1):
f.write("3 %d %d %d\n" %
(faces[face_id][0], faces[face_id][1], faces[face_id][2]))
f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2]))
f.write(
"\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default"
% len(faces))
for j, face in enumerate(faces):
if j % 9 == 0:
f.write("\n")
f.write("%d " % face_labels[j])
print('done writing')
transform_filter_grid = vtk.vtkTransformPolyDataFilter()
transform_filter_grid.SetTransform(transform)
transform_filter_grid.SetInputData(grid_3d)
transform_filter_grid.Update()
#grid_points = np.array( transform_filter.GetOutput().GetPoints().GetData() )
#grid_lines = np.array( transform_filter.GetOutput().GetLines().GetData() )
#poly = dsa.WrapDataObject(transform_filter.GetOutput()).Polygons
#faces = np.reshape(poly,(-1,4))[:,1:4]
#print('writing warped grid')
#with open(out_name, 'w+') as f:
#f.write("# vtk DataFile Version 4.2 \nvtk output \nASCII \n \nDATASET POLYDATA \nPOINTS %d float \n" % len(grid_points))
#for vi, v in enumerate(grid_points):
#vcol = ' %f %f %f' % (vcolor[vi, 0], vcolor[vi, 1], vcolor[vi, 2]) if vcolor is not None else ''
#f.write("%f %f %f\n" % (v[0], v[1], v[2]))
#f.write("LINES %d %d \n" % (len(grid_lines),2*len(grid_lines)-1))
#for lines_id in range(len(grid_lines) - 1):
#f.write("3 %d %d %d\n" % (grid_lines[face_id][0] , faces[face_id][1], faces[face_id][2]))
#f.write("3 %d %d %d" % (faces[-1][0], faces[-1][1], faces[-1][2]))
#f.write("\n \nCELL_DATA %d \nSCALARS scalars double \nLOOKUP_TABLE default" % len(faces))
#for j,face in enumerate(faces):
#if j%9 == 0:
#f.write("\n")
#f.write("%d " % face_labels[j])
#print('done writing')
filt = vtk.vtkConnectivityFilter()
filt.SetInputData(grid_3d) # get the data from the MC alg.
#filt.ColorRegionsOn()
filt.Update()
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
WIDTH = 640
HEIGHT = 480
renWin.SetSize(WIDTH, HEIGHT)
#create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# mapper
dataMapper1 = vtk.vtkPolyDataMapper()
dataMapper2 = vtk.vtkPolyDataMapper()
#dataMapper1.AddInputConnection(pd_in.GetOutputPort())
#dataMapper2.AddInputConnection(filt.GetOutputPort())
dataMapper1.AddInputConnection(transform_filter.GetOutputPort())
dataMapper2.AddInputConnection(transform_filter_grid.GetOutputPort())
#vtkPolyDataMapper = dataMapper.SetInputConnection(0,transform_filter.GetOutputPort())
#dataMapper.SetInputConnection(0,transform_filter.GetOutputPort())
#dataMapper.SetInputConnection(1,transform_filter_grid.GetOutputPort())
# actor
dataActor1 = vtk.vtkActor()
dataActor2 = vtk.vtkActor()
dataActor1.SetMapper(dataMapper1)
dataActor2.SetMapper(dataMapper2)
# assign actor to the renderer
ren.AddActor(dataActor1)
ren.AddActor(dataActor2)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# this is a tcl version of plate vibration
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# read a vtk file
#
plate = vtk.vtkPolyDataReader()
plate.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/plate.vtk")
plate.SetVectorsName("mode8")
warp = vtk.vtkWarpVector()
warp.SetInputConnection(plate.GetOutputPort())
warp.SetScaleFactor(0.5)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(warp.GetOutputPort())
color = vtk.vtkVectorDot()
color.SetInputConnection(normals.GetOutputPort())
lut = vtk.vtkLookupTable()
lut.SetNumberOfColors(256)
lut.Build()
i = 0
while i < 128:
lut.SetTableValue(i,expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),expr.expr(globals(), locals(),["(","128.0","-i",")/","128.0"]),1)
i = i + 1
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# read data
#
input = vtk.vtkPolyDataReader()
input.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/brainImageSmooth.vtk")
#
# generate vectors
clean = vtk.vtkCleanPolyData()
clean.SetInputConnection(input.GetOutputPort())
smooth = vtk.vtkWindowedSincPolyDataFilter()
smooth.SetInputConnection(clean.GetOutputPort())
smooth.GenerateErrorVectorsOn()
smooth.GenerateErrorScalarsOn()
smooth.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(smooth.GetOutputPort())
mapper.SetScalarRange(smooth.GetOutput().GetScalarRange())
brain = vtk.vtkActor()
brain.SetMapper(mapper)
def flow(mesh_file, iter_num, show_flow=False):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(mesh_file)
reader.Update()
mesh = reader.GetOutput()
tol = 0.05
q = 1.0
dt = 0.001
orig_mesh = mesh
prev_mesh = mesh
thin_plate_spline_list = []
for i in range(iter_num + 1):
deformed_surface_writer = vtk.vtkPolyDataWriter()
deformed_surface_writer.SetFileName('data/flow/' + str(i) + '.vtk')
deformed_surface_writer.SetInputData(mesh)
deformed_surface_writer.Update()
taubin_smooth = vtk.vtkWindowedSincPolyDataFilter()
taubin_smooth.SetInputData(mesh)
taubin_smooth.SetNumberOfIterations(20)
taubin_smooth.BoundarySmoothingOff()
taubin_smooth.FeatureEdgeSmoothingOff()
taubin_smooth.SetPassBand(0.01)
taubin_smooth.NonManifoldSmoothingOn()
taubin_smooth.NormalizeCoordinatesOn()
taubin_smooth.Update()
mesh = taubin_smooth.GetOutput()
normal_generator = vtk.vtkPolyDataNormals()
normal_generator.SetInputData(mesh)
normal_generator.SplittingOff()
normal_generator.ComputePointNormalsOn()
normal_generator.ComputeCellNormalsOff()
normal_generator.Update()
mesh = normal_generator.GetOutput()
curvatures = vtk.vtkCurvatures()
curvatures.SetCurvatureTypeToMean()
curvatures.SetInputData(mesh)
curvatures.Update()
mean_curvatures = curvatures.GetOutput().GetPointData().GetArray("Mean_Curvature")
normals = normal_generator.GetOutput().GetPointData().GetNormals()
mesh_pts = mesh.GetPoints()
for j in range(mesh.GetNumberOfPoints()):
current_point = mesh.GetPoint(j)
current_normal = np.array(normals.GetTuple3(j))
current_mean_curvature = mean_curvatures.GetValue(j)
pt = np.array(mesh_pts.GetPoint(j))
pt -= dt * current_mean_curvature * current_normal
mesh_pts.SetPoint(j, pt)
mesh_pts.Modified()
mesh.SetPoints(mesh_pts)
mesh.Modified()
# if i % 100 == 0 and show_flow:
# plotter = pyvista.Plotter()
# plotter.add_mesh(mesh)
# plotter.show()
tps_deform = get_thin_plate_spline_deform(prev_mesh, mesh)
prev_mesh = mesh
thin_plate_spline_list.append(tps_deform)
# new_mesh = apply_tps_on_spokes_poly(mesh, thin_plate_spline_list)
# plotter = pyvista.Plotter()
# plotter.add_mesh(new_mesh, color='red', opacity=0.3)
# plotter.add_mesh(orig_mesh, color='blue', opacity=0.3)
# plotter.show()
return mesh, thin_plate_spline_list
def addColors(infilename,
outfilename,
colorfilename=None,
colorstring=None,
binary=True,
verbose=False):
"""add color array"""
outformat = path.splitext(outfilename)[1].strip('.')
if outformat != 'ply':
raise ValueError('colors are only supported for PLY format')
informat = path.splitext(infilename)[1].strip('.')
# set reader based on filename extension
if informat == 'stl':
reader = vtk.vtkSTLReader()
elif informat == 'vtk':
reader = vtk.vtkPolyDataReader()
elif informat == 'obj':
reader = vtk.vtkMNIObjectReader()
elif informat == 'ply':
reader = vtk.vtkPLYReader()
elif informat == 'vtp':
reader = vtk.vtkXMLPolyDataReader()
else:
raise ValueError('cannot read input format: ' + informat)
reader.SetFileName(infilename)
reader.Update()
#N = reader.GetOutput().GetNumberOfPolys()
N = reader.GetOutput().GetNumberOfPoints()
if verbose:
print("read %i points (vertices)" % (N, ))
if colorfilename:
colorar = readColorFile(colorfilename)
if N != colorar.shape[0]:
raise ValueError('number of rows in color file does not match' +
'number of points in mesh file')
elif colorstring:
color = [int(i) for i in colorstring.split()]
colorar = np.ones((N, 3)) * np.array(color)
Colors = vtk.vtkUnsignedCharArray()
Colors.SetNumberOfComponents(3)
Colors.SetName("Colors")
for i in range(0, N):
Colors.InsertNextTuple3(*colorar[i, :])
polydata = vtk.vtkPolyData()
polydata = reader.GetOutput()
polydata.GetPointData().SetScalars(Colors)
polydata.Modified()
writer = vtk.vtkPLYWriter()
writer.SetArrayName("Colors")
writer.SetInputData(polydata)
writer.SetFileName(outfilename)
if binary:
if verbose: print('setting output to binary')
writer.SetFileTypeToBinary()
else:
if verbose: print('setting output to ascii')
writer.SetFileTypeToASCII()
err = writer.Write()
