def GetRawDICOMData(filenames,fileID):
print filenames,fileID
vtkRealDcmReader = vtk.vtkDICOMImageReader()
vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) )
vtkRealDcmReader.Update()
vtkRealData = vtk.vtkImageCast()
vtkRealData.SetOutputScalarTypeToFloat()
vtkRealData.SetInput( vtkRealDcmReader.GetOutput() )
vtkRealData.Update( )
real_image = vtkRealData.GetOutput().GetPointData()
real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0))
vtkImagDcmReader = vtk.vtkDICOMImageReader()
vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) )
vtkImagDcmReader.Update()
vtkImagData = vtk.vtkImageCast()
vtkImagData.SetOutputScalarTypeToFloat()
vtkImagData.SetInput( vtkImagDcmReader.GetOutput() )
vtkImagData.Update( )
imag_image = vtkImagData.GetOutput().GetPointData()
imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0))
vtkAppend = vtk.vtkImageAppendComponents()
vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() )
vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() )
vtkAppend.Update( )
# write raw data
vtkRawData = vtkAppend.GetOutput()
vtkRawData.SetSpacing( spacing )
vtkDcmWriter = vtk.vtkDataSetWriter()
vtkDcmWriter.SetFileTypeToBinary()
vtkDcmWriter.SetFileName("s%d/rawdata.%04d.vtk" % (dirID,fileID) )
vtkDcmWriter.SetInput( vtkRawData )
vtkDcmWriter.Update()
# write raw phase data
vtkPhase = vtk.vtkImageMathematics()
vtkPhase.SetInput1( vtkRealData.GetOutput() )
vtkPhase.SetInput2( vtkImagData.GetOutput() )
vtkPhase.SetOperationToATAN2( )
vtkPhase.Update( )
vtkPhaseData = vtkPhase.GetOutput()
vtkPhaseData.SetSpacing( spacing )
vtkDcmWriter = vtk.vtkDataSetWriter()
vtkDcmWriter.SetFileTypeToBinary()
vtkDcmWriter.SetFileName("s%d/phase.%04d.vtk" % (dirID,fileID) )
vtkDcmWriter.SetInput( vtkPhaseData)
vtkDcmWriter.Update()
return (real_array,imag_array)
def testVtkRenderPixelExact_():
import vtkcommon
import vtk
import matplotlib.pyplot as pyplot
res = (10, 20, 0)
im = np.zeros(res[:2], dtype=np.uint8)
for (x,y) in np.ndindex(*res[:2]):
if x&1 and y&1:
im[(x,y)] = 1
for (x,y) in np.ndindex(res[0], 1):
im[(x,res[1]-1)] = 1
ds = vtkcommon.vtkImageData(cell_shape=res, spacing = (30., 30., 30.), origin=-np.asarray(res)*30.*0.5)
vtkcommon.vtkImageDataAddData(ds, im, "CellData", "testdata")
ds.GetCellData().SetActiveScalars("testdata")
x0, x1, y0, y1, _, _ = vtkcommon.vtkGetDataSetBounds(ds, mode='[xxyyzz]')
back_im, = vtkcommon.vtkImageDataToNumpy(ds)
print 'numpy -> vtk -> numpy is identity operation:', np.all(im == back_im)
writer = vtk.vtkDataSetWriter()
writer.SetInput(ds)
writer.SetFileName("plottest-org.vtk")
writer.Update()
vtkimg = vtkcommon.vtkRender2d(ds, matplotlib.cm.spectral, (-1, 2), 30.)
writer = vtk.vtkDataSetWriter()
writer.SetInput(vtkimg)
writer.SetFileName("plottest-img.vtk")
writer.Update()
writer = vtk.vtkPNGWriter()
writer.SetInput(vtkimg)
writer.SetFileName("plottest-img.png")
writer.Write()
img, = vtkcommon.vtkImageDataToNumpy(vtkimg)
pdfpages = PdfPages("plottest-img.pdf")
fig = pyplot.figure()
pyplot.subplot(121)
pyplot.imshow(vtkcommon.npImageLayout(img), extent = (x0, x1, y0, y1), interpolation='nearest')
pyplot.subplot(122)
pyplot.imshow(vtkcommon.npImageLayout(im), extent = (x0, x1, y0, y1), interpolation='nearest')
pdfpages.savefig(fig)
pdfpages.close()
def GetRawDICOMData(filenames,fileID):
print filenames,fileID
vtkRealDcmReader = vtk.vtkDICOMImageReader()
vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) )
vtkRealDcmReader.Update()
vtkRealData = vtk.vtkImageCast()
vtkRealData.SetOutputScalarTypeToFloat()
vtkRealData.SetInput( vtkRealDcmReader.GetOutput() )
vtkRealData.Update( )
real_image = vtkRealData.GetOutput().GetPointData()
real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0))
vtkImagDcmReader = vtk.vtkDICOMImageReader()
vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) )
vtkImagDcmReader.Update()
vtkImagData = vtk.vtkImageCast()
vtkImagData.SetOutputScalarTypeToFloat()
vtkImagData.SetInput( vtkImagDcmReader.GetOutput() )
vtkImagData.Update( )
imag_image = vtkImagData.GetOutput().GetPointData()
imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0))
vtkAppend = vtk.vtkImageAppendComponents()
vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() )
vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() )
vtkAppend.Update( )
vtkDcmWriter = vtk.vtkDataSetWriter()
vtkDcmWriter.SetFileName("rawdata.%04d.vtk" % fileID )
vtkDcmWriter.SetInput(vtkAppend.GetOutput())
vtkDcmWriter.Update()
return (real_array,imag_array)
def write(self, mesh_points, filename):
"""
Writes a vtk file, called filename, copying all the
structures from self.filename but the coordinates.
`mesh_points` is a matrix that contains the new coordinates
to write in the vtk file.
:param numpy.ndarray mesh_points: it is a `n_points`-by-3
matrix containing the coordinates of the points of the
mesh
:param string filename: name of the output file.
"""
self._check_filename_type(filename)
self._check_extension(filename)
self._check_infile_instantiation()
self.outfile = filename
reader = vtk.vtkDataSetReader()
reader.SetFileName(self.infile)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
data = reader.GetOutput()
points = vtk.vtkPoints()
for i in range(data.GetNumberOfPoints()):
points.InsertNextPoint(mesh_points[i, :])
data.SetPoints(points)
writer = vtk.vtkDataSetWriter()
writer.SetFileName(self.outfile)
writer.SetInputData(data)
writer.Write()
def write(self, mesh_points, filename):
"""
Writes a vtk file, called filename, copying all the
structures from self.filename but the coordinates.
`mesh_points` is a matrix that contains the new coordinates
to write in the vtk file.
:param numpy.ndarray mesh_points: it is a `n_points`-by-3
matrix containing the coordinates of the points of the
mesh
:param string filename: name of the output file.
"""
self._check_filename_type(filename)
self._check_extension(filename)
self._check_infile_instantiation()
self.outfile = filename
reader = vtk.vtkDataSetReader()
reader.SetFileName(self.infile)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
data = reader.GetOutput()
points = vtk.vtkPoints()
for i in range(data.GetNumberOfPoints()):
points.InsertNextPoint(mesh_points[i, :])
data.SetPoints(points)
writer = vtk.vtkDataSetWriter()
writer.SetFileName(self.outfile)
writer.SetInputData(data)
writer.Write()
def _save_polydata(self, data, write_bin=False):
"""
This private method saves into `filename` the `data`. `data` is a
vtkPolydata. It is possible to specify format for `filename`: if
`write_bin` is True, file is written in binary format, otherwise in
ASCII format. This method save cached polydata to reduce number of IO
operations.
:param vtkPolyData data: polydatat to save.
:param bool write_bin: for binary format file.
"""
self._cached_data = data
writer = vtk.vtkDataSetWriter()
if write_bin:
writer.SetFileTypeToBinary()
writer.SetFileName(self._filename)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(data)
else:
writer.SetInputData(data)
writer.Write()
def writearclength(numpoints, rawpoints, outputVTK):
slicerOrientation = vtk.vtkPoints()
slicerOrientation.SetNumberOfPoints(numpoints)
for idpoint in range(numpoints):
slicerOrientation.SetPoint(idpoint, rawpoints[idpoint][0],
rawpoints[idpoint][1],
rawpoints[idpoint][2])
# loop over points an store in vtk data structure
arclength = 0.0
vertices = vtk.vtkCellArray()
for idpoint in range(slicerOrientation.GetNumberOfPoints() - 1):
line = vtk.vtkLine()
line.GetPointIds().SetId(0, idpoint)
line.GetPointIds().SetId(1, idpoint + 1)
arclength = arclength + math.sqrt(
vtk.vtkMath.Distance2BetweenPoints(rawpoints[idpoint],
rawpoints[idpoint + 1]))
vertices.InsertNextCell(line)
print "arclength = ", arclength
# set polydata
polydata = vtk.vtkPolyData()
polydata.SetPoints(slicerOrientation)
polydata.SetLines(vertices)
# write to file
polydatawriter = vtk.vtkDataSetWriter()
polydatawriter.SetFileName(outputVTK)
polydatawriter.SetInputData(polydata)
polydatawriter.Update()
return arclength
def __repr__(self):
"""ASCII representation of the VTK data."""
writer = vtk.vtkDataSetWriter()
writer.SetHeader(f'# {util.execution_stamp("VTK")}')
writer.WriteToOutputStringOn()
writer.SetInputData(self.vtk_data)
writer.Write()
return writer.GetOutputString()
def __repr__(self):
"""ASCII representation of the VTK data."""
writer = vtk.vtkDataSetWriter()
writer.SetHeader('# DAMASK.VTK v{}'.format(version))
writer.WriteToOutputStringOn()
writer.SetInputData(self.geom)
writer.Write()
return writer.GetOutputString()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkDataSetWriter(),
'Writing vtkDataSet.',
('vtkDataSet', ), (),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def pickle_vtk(mesh):
writer = vtk.vtkDataSetWriter() # create instance of writer
writer.SetInputDataObject(mesh) # input the data as a vtk object
writer.SetWriteToOutputString(True) # instead of writing to file
writer.SetFileTypeToASCII()
writer.Write()
to_serialize = writer.GetOutputString()
output = pickle.dumps(to_serialize, protocol=pickle.HIGHEST_PROTOCOL)
return output
def write(self,
output_values,
filename,
output_name=None,
write_bin=False):
"""
Writes a mat file, called filename. output_values is a matrix that contains the new values of the output
to write in the mat file.
:param numpy.ndarray output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output.
:param string filename: name of the output file.
:param string output_name: name of the output of interest inside the mat file.
If it is not passed, it is equal to self.output_name.
:param bool write_bin: flag to write in the binary format. Default is False.
"""
self._check_filename_type(filename)
self._check_extension(filename)
self._check_infile_instantiation(self.infile)
if output_name is None:
output_name = self.output_name
else:
self._check_filename_type(output_name)
reader = vtk.vtkDataSetReader()
reader.SetFileName(self.infile)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
data = reader.GetOutput()
output_array = ns.numpy_to_vtk(num_array=output_values,
array_type=vtk.VTK_DOUBLE)
output_array.SetName(output_name)
if self.cell_data is True:
data.GetCellData().AddArray(output_array)
else:
data.GetPointData().AddArray(output_array)
writer = vtk.vtkDataSetWriter()
if write_bin:
writer.SetFileTypeToBinary()
writer.SetFileName(filename)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(data)
else:
writer.SetInputData(data)
writer.Write()
def __getstate__(self):
"""Support pickle. Serialize the VTK object to ASCII string."""
state = self.__dict__.copy()
writer = vtk.vtkDataSetWriter()
writer.SetInputDataObject(self)
writer.SetWriteToOutputString(True)
writer.SetFileTypeToASCII()
writer.Write()
to_serialize = writer.GetOutputString()
state['vtk_serialized'] = to_serialize
return state
def writer_vtk(filename, data):
"""
Util function to create a vtk file
:param filename: the name of the file
:param data: A Polydata you wish to write
:return: void
"""
writer = vtk.vtkDataSetWriter()
writer.SetFileName(filename)
writer.SetInputData(data)
writer.Write()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self,
module_manager,
vtk.vtkDataSetWriter(),
"Writing vtkDataSet.",
("vtkDataSet",),
(),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None,
)
def write(self):
writer=vtk.vtkDataSetWriter()
writer.SetInput(self.reslice.GetOutput())
#proboje wczytac workspace z pliku, jesli sie nie uda to otwiera folder w ktorym sie znajduje plik
try:
dir=ReadFile().read_variable('output_folder:')
print dir
except:
dir=""
self.filename=asksaveasfilename(initialdir=dir,filetypes=[("allfiles","*"),("VTKfiles","*.vtk")])
writer.SetFileName(self.filename)
writer.Write()
def dump2VTK(obj,fnm=None):
global dumps
if fnm is None:
fnm="foo%.3i.vtk" % dumps
dumps+=1
dsw = vtk.vtkDataSetWriter()
dsw.SetFileName(fnm)
try:
dsw.SetInputData(obj)
except:
dsw.SetInputConnection(obj.GetOutputPort())
dsw.Write()
def write(self, output_values, filename, output_name=None, write_bin=False): """ Writes a mat file, called filename. output_values is a matrix that contains the new values of the output to write in the mat file. :param numpy.ndarray output_values: it is a `n_points`-by-1 matrix containing the values of the chosen output. :param string filename: name of the output file. :param string output_name: name of the output of interest inside the mat file. If it is not passed, it is equal to self.output_name. :param bool write_bin: flag to write in the binary format. Default is False. """ self._check_filename_type(filename) self._check_extension(filename) self._check_infile_instantiation(self.infile) if output_name is None: output_name = self.output_name else: self._check_filename_type(output_name) reader = vtk.vtkDataSetReader() reader.SetFileName(self.infile) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() data = reader.GetOutput() output_array = ns.numpy_to_vtk(num_array=output_values,array_type=vtk.VTK_DOUBLE) output_array.SetName(output_name) if self.cell_data is True: data.GetCellData().AddArray(output_array) else: data.GetPointData().AddArray(output_array) writer = vtk.vtkDataSetWriter() if write_bin: writer.SetFileTypeToBinary() writer.SetFileName(filename) if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(data) else: writer.SetInputData(data) writer.Write()
def write(self):
writer = vtk.vtkDataSetWriter()
writer.SetInput(self.reslice.GetOutput())
#proboje wczytac workspace z pliku, jesli sie nie uda to otwiera folder w ktorym sie znajduje plik
try:
dir = ReadFile().read_variable('output_folder:')
print dir
except:
dir = ""
self.filename = asksaveasfilename(initialdir=dir,
filetypes=[("allfiles", "*"),
("VTKfiles", "*.vtk")])
writer.SetFileName(self.filename)
writer.Write()
def TestXdmfConversion(dataInput, fileName):
global CleanUpGood, timer
fileName = OutputDir + fileName
xdmfFile = fileName + ".xmf"
hdf5File = fileName + ".h5"
vtkFile = fileName + ".vtk"
xWriter = vtk.vtkXdmf3Writer()
xWriter.SetLightDataLimit(LightDataLimit)
xWriter.WriteAllTimeStepsOn()
xWriter.SetFileName(xdmfFile)
xWriter.SetInputData(dataInput)
timer.StartTimer()
xWriter.Write()
timer.StopTimer()
print "vtkXdmf3Writer took", timer.GetElapsedTime(), "seconds to write",\
xdmfFile
ds = vtk.vtkDataSet.SafeDownCast(dataInput)
if ds:
dsw = vtk.vtkDataSetWriter()
dsw.SetFileName(vtkFile)
dsw.SetInputData(ds)
dsw.Write()
if not DoFilesExist(xdmfFile, None, None, False):
message = "Writer did not create " + xdmfFile
raiseErrorAndExit(message)
xReader = vtk.vtkXdmf3Reader()
xReader.SetFileName(xdmfFile)
timer.StartTimer()
xReader.Update()
timer.StopTimer()
print "vtkXdmf3Reader took", timer.GetElapsedTime(), "seconds to read",\
xdmfFile
rOutput = xReader.GetOutputDataObject(0)
fail = DoDataObjectsDiffer(dataInput, rOutput)
if fail:
raiseErrorAndExit("Xdmf conversion test failed")
else:
if ds:
DoFilesExist(xdmfFile, hdf5File, vtkFile, CleanUpGood)
else:
DoFilesExist(xdmfFile, hdf5File, None, CleanUpGood)
def TestXdmfConversion(dataInput, fileName):
global CleanUpGood, timer
fileName = OutputDir + fileName
xdmfFile = fileName + ".xmf"
hdf5File = fileName + ".h5"
vtkFile = fileName + ".vtk"
xWriter = vtk.vtkXdmf3Writer()
xWriter.SetLightDataLimit(LightDataLimit)
xWriter.WriteAllTimeStepsOn()
xWriter.SetFileName(xdmfFile)
xWriter.SetInputData(dataInput)
timer.StartTimer()
xWriter.Write()
timer.StopTimer()
print "vtkXdmf3Writer took", timer.GetElapsedTime(), "seconds to write",\
xdmfFile
ds = vtk.vtkDataSet.SafeDownCast(dataInput)
if ds:
dsw = vtk.vtkDataSetWriter()
dsw.SetFileName(vtkFile)
dsw.SetInputData(ds)
dsw.Write()
if not DoFilesExist(xdmfFile, None, None, False):
message = "Writer did not create " + xdmfFile
raiseErrorAndExit(message)
xReader = vtk.vtkXdmf3Reader()
xReader.SetFileName(xdmfFile)
timer.StartTimer()
xReader.Update()
timer.StopTimer()
print "vtkXdmf3Reader took", timer.GetElapsedTime(), "seconds to read",\
xdmfFile
rOutput = xReader.GetOutputDataObject(0)
fail = DoDataObjectsDiffer(dataInput, rOutput)
if fail:
raiseErrorAndExit("Xdmf conversion test failed")
else:
if ds:
DoFilesExist(xdmfFile, hdf5File, vtkFile, CleanUpGood)
else:
DoFilesExist(xdmfFile, hdf5File, None, CleanUpGood)
def WriteVTKPoints(vtkpoints,OutputFileName):
# loop over points an store in vtk data structure
#vtkpoints = vtk.vtkPoints()
vertices= vtk.vtkCellArray()
for idpoint in range(vtkpoints.GetNumberOfPoints()):
#vertices.InsertNextCell( 1 ); vertices.InsertCellPoint( vtkpoints.InsertNextPoint(point) )
vertices.InsertNextCell( 1 ); vertices.InsertCellPoint( idpoint )
# set polydata
polydata = vtk.vtkPolyData()
polydata.SetPoints(vtkpoints)
polydata.SetVerts( vertices )
# write to file
polydatawriter = vtk.vtkDataSetWriter()
polydatawriter.SetFileName(OutputFileName)
polydatawriter.SetInput(polydata)
polydatawriter.Update()
def dump2VTK(obj, fnm=None):
global dumps
if fnm[:-4].lower() != ".vtk":
fnm += ".vtk"
if fnm is None:
fnm = "foo.vtk" % dumps
if fnm in dumps:
dumps[fnm] += 1
fnm = fnm[:-4] + "%.3i.vtk" % dumps[fnm]
else:
dumps[fnm] = 0
dsw = vtk.vtkDataSetWriter()
dsw.SetFileName(fnm)
try:
dsw.SetInputData(obj)
except:
dsw.SetInputConnection(obj.GetOutputPort())
dsw.Write()
def WriteVTKTemplateImage(TemplateFilename):
import vtk
import vtk.util.numpy_support as vtkNumPy
import numpy
# set Image Template Dimensions
femBounds = (0.0, 0.04, -0.04, 0.04, -0.03, 0.06)
origin = (femBounds[0], femBounds[2], femBounds[4])
spacing = ((femBounds[1] - femBounds[0]) / imageDimensions[0],
(femBounds[3] - femBounds[2]) / imageDimensions[1],
(femBounds[5] - femBounds[4]) / imageDimensions[2])
print femBounds, origin, spacing
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# array is converted to a string of chars and imported.
# numpy array stored as ROW MAJOR
# MUST write out in COLUMN MAJOR format to be the same as VTK
data_string = numpy.zeros(imageDimensions, dtype=numpy.float,
order='F').tostring(order='F')
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, imageDimensions[0] - 1, 0,
imageDimensions[1] - 1, 0,
imageDimensions[2] - 1)
dataImporter.SetWholeExtent(0, imageDimensions[0] - 1, 0,
imageDimensions[1] - 1, 0,
imageDimensions[2] - 1)
dataImporter.SetDataSpacing(spacing)
dataImporter.SetDataOrigin(origin)
dataImporter.SetScalarArrayName("scalars")
dataImporter.Update()
vtkTemplateWriter = vtk.vtkDataSetWriter()
vtkTemplateWriter.SetFileName(TemplateFilename)
vtkTemplateWriter.SetInput(dataImporter.GetOutput())
vtkTemplateWriter.Update()
return
def dump2VTK(obj,fnm=None):
global dumps
if fnm is None:
fnm="foo.vtk" % dumps
if fnm[:-4].lower()!=".vtk":
fnm+=".vtk"
if fnm in dumps:
dumps[fnm]+=1
fnm=fnm[:-4]+"%.3i.vtk" % dumps[fnm]
else:
dumps[fnm]=0
dsw = vtk.vtkDataSetWriter()
dsw.SetFileName(fnm)
try:
dsw.SetInputData(obj)
except:
dsw.SetInputConnection(obj.GetOutputPort())
dsw.Write()
def saveLandmarks_vtk(subjlist, landmarkDict):
#saves .vtk with the landmarks for single subject
import vtk
for i in range(len(subjlist)):
landmarks = landmarkDict[subjlist[i]]
vtkfilename = subjlist[i] + '_landmarks.vtk'
Points = vtk.vtkPoints()
for i in range(len(landmarks)):
Points.InsertNextPoint(landmarks[i][0], landmarks[i][1],
landmarks[i][2])
polydata = vtk.vtkPolyData()
polydata.SetPoints(Points)
writer = vtk.vtkDataSetWriter()
writer.SetFileName(vtkfilename)
writer.SetInputData(polydata)
writer.Write()
def _save_polydata(self, data, write_bin=False):
"""
This private method saves into `filename` the `data`. `data` is a
vtkPolydata. It is possible to specify format for `filename`: if
`write_bin` is True, file is written in binary format, otherwise in
ASCII format. This method save cached polydata to reduce number of IO
operations.
:param vtkPolyData data: polydatat to save.
:param bool write_bin: for binary format file.
"""
self._cached_data = data
writer = vtk.vtkDataSetWriter()
if write_bin:
writer.SetFileTypeToBinary()
writer.SetFileName(self._filename)
writer.SetInputData(data)
writer.Write()
def save(self, filename, binary=True):
"""
Writes image data grid to disk.
Parameters
----------
filename : str
Filename of grid to be written. The file extension will select the
type of writer to use. ".vtk" will use the legacy writer, while
".vti" will select the VTK XML writer.
binary : bool, optional
Writes as a binary file by default. Set to False to write ASCII.
Notes
-----
Binary files write much faster than ASCII, but binary files written on
one system may not be readable on other systems. Binary can be used
only with the legacy writer.
"""
filename = os.path.abspath(os.path.expanduser(filename))
# Use legacy writer if vtk is in filename
if '.vtk' in filename:
writer = vtk.vtkDataSetWriter()
legacy = True
elif '.vti' in filename:
writer = vtk.vtkXMLImageDataWriter()
legacy = False
else:
raise Exception('Extension should be either ".vti" (xml) or' +
'".vtk" (legacy)')
# Write
writer.SetFileName(filename)
writer.SetInputData(self)
if binary and legacy:
writer.SetFileTypeToBinary()
writer.Write()
def WriteVTKTemplateImage( TemplateFilename ):
import vtk
import vtk.util.numpy_support as vtkNumPy
import numpy
# set Image Template Dimensions
femBounds = (0.0,0.04,-0.04, 0.04, -0.03,0.06)
origin = (femBounds[0], femBounds[2], femBounds[4])
spacing = ( (femBounds[1]-femBounds[0])/ imageDimensions[0] ,
(femBounds[3]-femBounds[2])/ imageDimensions[1] ,
(femBounds[5]-femBounds[4])/ imageDimensions[2]
)
print femBounds, origin, spacing
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# array is converted to a string of chars and imported.
# numpy array stored as ROW MAJOR
# MUST write out in COLUMN MAJOR format to be the same as VTK
data_string = numpy.zeros(imageDimensions,dtype=numpy.float,order='F').tostring(order='F')
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent( 0, imageDimensions[0]-1, 0, imageDimensions[1]-1, 0, imageDimensions[2]-1)
dataImporter.SetWholeExtent(0, imageDimensions[0]-1, 0, imageDimensions[1]-1, 0, imageDimensions[2]-1)
dataImporter.SetDataSpacing( spacing )
dataImporter.SetDataOrigin( origin )
dataImporter.SetScalarArrayName( "scalars" )
dataImporter.Update()
vtkTemplateWriter = vtk.vtkDataSetWriter()
vtkTemplateWriter.SetFileName( TemplateFilename )
vtkTemplateWriter.SetInput( dataImporter.GetOutput() )
vtkTemplateWriter.Update()
return
def WriteVTKPoints(self,vtkpoints,OutputFileName):
# loop over points an store in vtk data structure
# write in meters
MillimeterMeterConversion = .001;
scalevtkPoints = vtk.vtkPoints()
vertices= vtk.vtkCellArray()
for idpoint in range(vtkpoints.GetNumberOfPoints()):
point = MillimeterMeterConversion * numpy.array(vtkpoints.GetPoint(idpoint))
vertices.InsertNextCell( 1 ); vertices.InsertCellPoint( scalevtkPoints.InsertNextPoint(point) )
#vertices.InsertNextCell( 1 ); vertices.InsertCellPoint( idpoint )
# set polydata
polydata = vtk.vtkPolyData()
polydata.SetPoints(scalevtkPoints )
polydata.SetVerts( vertices )
# write to file
print "WriteVTKPoints: writing",OutputFileName
polydatawriter = vtk.vtkDataSetWriter()
polydatawriter.SetFileName(OutputFileName)
polydatawriter.SetInput(polydata)
polydatawriter.Update()
def WriteVTKPoints(self, vtkpoints, OutputFileName):
# loop over points an store in vtk data structure
# write in meters
MillimeterMeterConversion = .001
scalevtkPoints = vtk.vtkPoints()
vertices = vtk.vtkCellArray()
for idpoint in range(vtkpoints.GetNumberOfPoints()):
point = MillimeterMeterConversion * numpy.array(
vtkpoints.GetPoint(idpoint))
vertices.InsertNextCell(1)
vertices.InsertCellPoint(scalevtkPoints.InsertNextPoint(point))
#vertices.InsertNextCell( 1 ); vertices.InsertCellPoint( idpoint )
# set polydata
polydata = vtk.vtkPolyData()
polydata.SetPoints(scalevtkPoints)
polydata.SetVerts(vertices)
# write to file
print "WriteVTKPoints: writing", OutputFileName
polydatawriter = vtk.vtkDataSetWriter()
polydatawriter.SetFileName(OutputFileName)
polydatawriter.SetInput(polydata)
polydatawriter.Update()
def write(self, filename):
if len(self.data) > 1 or (VtkFiles in self.data
and len(self.data[VtkFiles]) > 1):
raise RuntimeError('cannot save data on multiple grids')
k, g = self.data.popitem()
if k == VtkFiles:
g = g.pop()
ext = '.vtk' if g.attrs['TYPE'] == 'VTK_FILE' else '.vtu'
f = open(os.path.splitext(filename)[0] + ext, 'wb')
f.write(np.asarray(g).tostring())
f.close()
else:
#ds = vtkcommon.vtkImageDataFromLd(self.file[k].attrs)
#ld = ku.read_lattice_data_from_hdf(self.file[k])
fn = str(self.file[k].file.filename)
path = str(self.file[k].name)
Pyld = ku.read_lattice_data_from_hdf_by_filename(fn, path)
ds = vtkcommon.vtkImageDataFromLd(Pyld)
for q in g:
# iterate over hdf datasets and add them to the image data
try:
vtkcommon.vtkImageDataAddData(ds, q, 'CellData',
posixpath.basename(q.name))
except RuntimeError, e:
print 'Warning: cannot add data %s' % q.name
print ' Exception reads "%s"' % str(e)
pass
writer = vtk.vtkDataSetWriter()
if int(vtk.vtkVersion.GetVTKSourceVersion()[12]) > 5:
writer.SetInputData(ds)
else:
writer.SetInput(ds)
writer.SetFileName(os.path.splitext(filename)[0] + '.vtk')
writer.Write()
del ds
def ProjectImagingMesh(ini_file):
import vtk.util.numpy_support as vtkNumPy
import ConfigParser
import scipy.io as scipyio
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# read config file
config = ConfigParser.ConfigParser()
config.add_section("imaging")
config.add_section("fem")
config.set("imaging", "listoffset", "[0]")
config.read(ini_file)
# get work directory
work_dir = config.get('fem', 'work_dir')
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
RotateX = float(config.get('fem', 'rotatex'))
RotateY = float(config.get('fem', 'rotatey'))
RotateZ = float(config.get('fem', 'rotatez'))
Translate = eval(config.get('fem', 'translate'))
Scale = eval(config.get('fem', 'scale'))
print "rotate", RotateX, RotateY, RotateZ, "translate", Translate, "scale", Scale
# read imaging data geometry that will be used to project FEM data onto
dimensions = eval(config.get('imaging', 'dimensions'))
spacing = eval(config.get('imaging', 'spacing'))
origin = eval(config.get('imaging', 'origin'))
print spacing, origin, dimensions
templateImage = CreateVTKImage(dimensions, spacing, origin)
# write template image for position verification
vtkTemplateWriter = vtk.vtkDataSetWriter()
vtkTemplateWriter.SetFileName("%s/imageTemplate.vtk" % work_dir)
vtkTemplateWriter.SetInput(templateImage)
vtkTemplateWriter.Update()
#setup to interpolate at 5 points across axial dimension
TransformList = []
listoffset = eval(config.get('imaging', 'listoffset'))
naverage = len(listoffset)
try:
subdistance = spacing[2] / (naverage - 1)
except ZeroDivisionError:
subdistance = 0.0 # default is not to offset
print "listoffset", listoffset, "subspacing distance = ", subdistance
for idtransform in listoffset:
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate(Translate[0], Translate[1],
Translate[2] + subdistance * idtransform)
AffineTransform.RotateZ(RotateZ)
AffineTransform.RotateY(RotateY)
AffineTransform.RotateX(RotateX)
AffineTransform.Scale(Scale)
TransformList.append(AffineTransform)
#laserTip = AffineTransform.TransformPoint( laserTip )
#laserOrientation = AffineTransform.TransformVector( laserOrientation )
# Interpolate FEM onto imaging data structures
vtkExodusIIReader = vtk.vtkExodusIIReader()
#vtkExodusIIReader.SetFileName( "%s/fem_stats.e" % work_dir )
#vtkExodusIIReader.SetPointResultArrayStatus("Mean0",1)
#vtkExodusIIReader.SetPointResultArrayStatus("StdDev0",1)
#Timesteps = 120
meshFileList = eval(config.get('fem', 'mesh_files'))
print meshFileList
for mesh_filename in meshFileList:
vtkExodusIIReader.SetFileName("%s/%s" % (work_dir, mesh_filename))
#vtkExodusIIReader.SetPointResultArrayStatus("Vard0Mean",1)
#vtkExodusIIReader.SetPointResultArrayStatus("Vard0Kurt",1)
vtkExodusIIReader.Update()
numberofresultarrays = vtkExodusIIReader.GetNumberOfPointResultArrays()
print numberofresultarrays
for resultarrayindex in range(numberofresultarrays):
resultarrayname = vtkExodusIIReader.GetPointResultArrayName(
resultarrayindex)
vtkExodusIIReader.SetPointResultArrayStatus(
"%s" % (resultarrayname), 1)
print resultarrayname
vtkExodusIIReader.Update()
ntime = vtkExodusIIReader.GetNumberOfTimeSteps()
#print ntime
#for timeID in range(69,70):
for timeID in range(ntime):
vtkExodusIIReader.SetTimeStep(timeID)
vtkExodusIIReader.Update()
# reflect
vtkReflectX = vtk.vtkReflectionFilter()
vtkReflectX.SetPlaneToXMin()
vtkReflectX.SetInput(vtkExodusIIReader.GetOutput())
vtkReflectX.Update()
# reflect
vtkReflectY = vtk.vtkReflectionFilter()
vtkReflectY.SetPlaneToYMax()
vtkReflectY.SetInput(vtkReflectX.GetOutput())
vtkReflectY.Update()
# apply the average of the transform
mean_array = numpy.zeros(dimensions[0] * dimensions[1] *
dimensions[2])
std_array = numpy.zeros(dimensions[0] * dimensions[1] *
dimensions[2])
for affineFEMTranform in TransformList:
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = affineFEMTranform.GetConcatenatedTransform(
0).GetMatrix()
#print matrix
RotationMatrix = [[
matrix.GetElement(0, 0),
matrix.GetElement(0, 1),
matrix.GetElement(0, 2)
],
[
matrix.GetElement(1, 0),
matrix.GetElement(1, 1),
matrix.GetElement(1, 2)
],
[
matrix.GetElement(2, 0),
matrix.GetElement(2, 1),
matrix.GetElement(2, 2)
]]
Translation = [
matrix.GetElement(0, 3),
matrix.GetElement(1, 3),
matrix.GetElement(2, 3)
]
#print RotationMatrix
print Translation
TransformedFEMMesh = None
if vtkReflectY.GetOutput().IsA("vtkMultiBlockDataSet"):
AppendBlocks = vtk.vtkAppendFilter()
iter = vtkReflectY.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
# loop over blocks...
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform(affineFEMTranform)
vtkTransformFEMMesh.SetInput(curInput)
vtkTransformFEMMesh.Update()
AppendBlocks.AddInput(vtkTransformFEMMesh.GetOutput())
AppendBlocks.Update()
iter.GoToNextItem()
TransformedFEMMesh = AppendBlocks.GetOutput()
else:
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform(affineFEMTranform)
vtkTransformFEMMesh.SetInput(vtkReflectY.GetOutput())
vtkTransformFEMMesh.Update()
TransformedFEMMesh = vtkTransformFEMMesh.GetOutput()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput(templateImage)
vtkResample.SetSource(TransformedFEMMesh)
vtkResample.Update()
fem_point_data = vtkResample.GetOutput().GetPointData()
#meantmp = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Mean'))
#print meantmp.max()
#mean_array = mean_array + vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Mean'))
#std_array = std_array + vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Kurt'))
#print fem_array
#print type(fem_array )
# average
#mean_array = mean_array/naverage
#print mean_array.max()
#std_array = std_array /naverage
# write numpy to disk in matlab
#scipyio.savemat("%s/modelstats.navg%d.%04d.mat" % (work_dir,naverage,timeID), {'spacing':spacing, 'origin':origin,'Vard0Mean':mean_array,'Vard0Kurt':std_array })
# write output
print "writing ", timeID, mesh_filename, work_dir
vtkStatsWriter = vtk.vtkDataSetWriter()
vtkStatsWriter.SetFileTypeToBinary()
vtkStatsWriter.SetFileName(
"%s/modelstats.navg%d.%s.%04d.vtk" %
(work_dir, naverage, mesh_filename, timeID))
vtkStatsWriter.SetInput(vtkResample.GetOutput())
vtkStatsWriter.Update()
def writeFile(ifilter, filename):
dsw = vtk.vtkDataSetWriter()
dsw.SetInputConnection(ifilter.GetOutputPort())
dsw.SetFileName(filename)
dsw.Write()
def __init__(self, SEMDataDirectory,variableDictionary ):
self.DataDictionary = {}
self.DebugObjective = True
self.DebugObjective = False
self.ctx = cl.create_some_context()
self.queue = cl.CommandQueue(self.ctx)
self.prg = cl.Program(self.ctx, """
__kernel void diff_sq(__global const float *a,
__global const float *b, __global float *c)
{
int gid = get_global_id(0);
c[gid] = (a[gid] - b[gid]) * (a[gid] - b[gid]);
}
""").build()
# FIXME should this be different ?
self.SEMDataDirectory = SEMDataDirectory
# FIXME vtk needs to be loaded AFTER kernel is built
import vtk
import vtk.util.numpy_support as vtkNumPy
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
print "read SEM data"
start = time.clock()
vtkSEMReader = vtk.vtkXMLUnstructuredGridReader()
vtufileName = "%s/%d.vtu" % (self.SEMDataDirectory,0)
vtkSEMReader.SetFileName( vtufileName )
vtkSEMReader.SetPointArrayStatus("Temperature",1)
vtkSEMReader.Update()
elapsed = (time.clock() - start)
print "read SEM data", elapsed
# get registration parameters
# register the SEM data to MRTI
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([
float(variableDictionary['x_displace']),
float(variableDictionary['y_displace']),
float(variableDictionary['z_displace'])
])
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform.RotateZ( float(variableDictionary['z_rotate' ] ) )
AffineTransform.RotateY( float(variableDictionary['y_rotate' ] ) )
AffineTransform.RotateX( float(variableDictionary['x_rotate' ] ) )
AffineTransform.Scale([1.e0,1.e0,1.e0])
self.SEMRegister = vtk.vtkTransformFilter()
self.SEMRegister.SetInput(vtkSEMReader.GetOutput())
self.SEMRegister.SetTransform(AffineTransform)
self.SEMRegister.Update()
print "write transform output"
if ( self.DebugObjective ):
vtkSEMWriter = vtk.vtkDataSetWriter()
vtkSEMWriter.SetFileTypeToBinary()
semfileName = "%s/semtransform%04d.vtk" % (self.SEMDataDirectory,0)
print "writing ", semfileName
vtkSEMWriter.SetFileName( semfileName )
vtkSEMWriter.SetInput(self.SEMRegister.GetOutput())
vtkSEMWriter.Update()
def pennesModeling(**kwargs):
"""
treatment planning model
"""
# import needed modules
import petsc4py, numpy, sys
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
from petsc4py import PETSc
# break processors into separate communicators
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions, PETSc.COMM_WORLD)
# the original configuration ini file should be stored
config = kwargs['config_parser']
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# copy all values from the input file
for section in config.sections():
for name, value in config.items(section):
#print "%s/%s" % (section,name) , value
getpot.SetIniValue("%s/%s" % (section, name), value)
# nodeset 1 will be treated as dirichlet
dirichletID = 1
getpot.SetIniValue("bc/u_dirichlet", '%d' % dirichletID)
# set tissue lookup tables
k_0Table = {
"default": config.getfloat("thermal_conductivity", "k_0_healthy"),
"vessel": config.getfloat("thermal_conductivity", "k_0_healthy"),
"grey": config.getfloat("thermal_conductivity", "k_0_grey"),
"white": config.getfloat("thermal_conductivity", "k_0_white"),
"csf": config.getfloat("thermal_conductivity", "k_0_csf"),
"tumor": config.getfloat("thermal_conductivity", "k_0_tumor")
}
w_0Table = {
"default": config.getfloat("perfusion", "w_0_healthy"),
"vessel": config.getfloat("perfusion", "w_0_healthy"),
"grey": config.getfloat("perfusion", "w_0_grey"),
"white": config.getfloat("perfusion", "w_0_white"),
"csf": config.getfloat("perfusion", "w_0_csf"),
"tumor": config.getfloat("perfusion", "w_0_tumor")
}
mu_aTable = {
"default": config.getfloat("optical", "mu_a_healthy"),
"vessel": config.getfloat("optical", "mu_a_healthy"),
"grey": config.getfloat("optical", "mu_a_grey"),
"white": config.getfloat("optical", "mu_a_white"),
"csf": config.getfloat("optical", "mu_a_csf"),
"tumor": config.getfloat("optical", "mu_a_tumor")
}
mu_sTable = {
"default": config.getfloat("optical", "mu_s_healthy"),
"vessel": config.getfloat("optical", "mu_s_healthy"),
"grey": config.getfloat("optical", "mu_s_grey"),
"white": config.getfloat("optical", "mu_s_white"),
"csf": config.getfloat("optical", "mu_s_csf"),
"tumor": config.getfloat("optical", "mu_s_tumor")
}
labelTable = {
config.get("labels", "greymatter"): "grey",
config.get("labels", "whitematter"): "white",
config.get("labels", "csf"): "csf",
config.get("labels", "tumor"): "tumor",
config.get("labels", "vessel"): "vessel"
}
labelCount = {
"default": 0,
"grey": 0,
"white": 0,
"csf": 0,
"tumor": 0,
"vessel": 0
}
# imaging params
import vtk
import vtk.util.numpy_support as vtkNumPy
SegmentFile = config.get("exec", "segment_file")
# set the default reader based on extension
if (SegmentFile.split(".").pop() == "vtk"):
vtkImageReader = vtk.vtkDataSetReader
elif (SegmentFile.split(".").pop() == "vti"):
vtkImageReader = vtk.vtkXMLImageDataReader
else:
raise RuntimeError("uknown file")
# get dimension info from header
vtkSetupReader = vtkImageReader()
vtkSetupReader.SetFileName(SegmentFile)
vtkSetupReader.Update()
vtkImageMask = vtkSetupReader.GetOutput()
dimensions = vtkSetupReader.GetOutput().GetDimensions()
numberPointsImage = vtkSetupReader.GetOutput().GetNumberOfPoints()
spacing_mm = vtkSetupReader.GetOutput().GetSpacing()
origin_mm = vtkSetupReader.GetOutput().GetOrigin()
# convert to meters
spacing = [dx * .001 for dx in spacing_mm]
origin = [x0 * .001 for x0 in origin_mm]
# pass pointer to c++
image_cells = vtkImageMask.GetPointData()
data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray(0))
# need to pass numpy array's w/ Fortran storage... ie painful to debug
imageDataVec = PETSc.Vec().createWithArray(numpy.ravel(data_array,
order='F'),
comm=PETSc.COMM_SELF)
# FIXME - center around quadrature in out-of-plane direction
# FIXME - need better out of plane cooling model
quadratureOffset = 1. / numpy.sqrt(3.0) * spacing[2] / 2.0
# expecting roi and subsample of the form:
# roi = [(40,210),(30,220),(6,78)]
# subsample = [3,3,2]
ROI = eval(config.get('exec', 'roi'))
subsample = eval(config.get('exec', 'subsample'))
nelemROI = [(pixel[1] - pixel[0] - 1) / sub
for pixel, sub in zip(ROI, subsample)]
xbounds = [
origin[0] + spacing[0] * (ROI[0][0] + 0.5),
origin[0] + spacing[0] * (ROI[0][1] + 0.5)
]
ybounds = [
origin[1] + spacing[1] * (ROI[1][0] + 0.5),
origin[1] + spacing[1] * (ROI[1][1] + 0.5)
]
zbounds = [
origin[2] + spacing[2] * (ROI[2][0] + 0.5),
origin[2] + spacing[2] * (ROI[2][1] + 0.5)
]
if (petscRank == 0):
print "#points", numberPointsImage, "dimensions ", dimensions, "spacing ", spacing, "origin ", origin
print "ROI", ROI, "nelemROI ", nelemROI, "bounds", xbounds, ybounds, zbounds
#set to steady state solve
getpot.SetIniValue("steadystate/domain_0", "true")
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
#femMesh.SetupUnStructuredGrid(kwargs['mesh_file'],0,RotationMatrix, Translation )
#femMesh.ReadFile(kwargs['mesh_file'])
femMesh.SetupStructuredGrid(nelemROI, xbounds, ybounds, zbounds,
[2, 2, 2, 2, 2, 2])
# get output file name else set default name
try:
MeshOutputFile = config.get("exec", "exodus_file")
except ConfigParser.NoOptionError:
MeshOutputFile = "fem.e"
# add the data structures for the Background System Solve
# set deltat, number of time steps, power profile, and add system
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh, getpot)
#getpot.SetIniPower(1,[[19,119],[90.0,100.0]] )
getpot.SetIniPower(1, kwargs['powerHistory'])
# AddPennesSDASystem
# AddPennesRFSystem
# AddPennesDeltaPSystem
pennesSystem = eval("eqnSystems.%s('StateSystem',kwargs['deltat'])" %
kwargs['physics'])
pennesSystem.AddStorageVectors(kwargs['ntime'] + 1)
# add system for labels
# FIXME: need both nodal, for dirichlet bc, and element version, for parameter masks
maskElemSystem = eqnSystems.AddExplicitSystem("ElemImageMask")
maskElemSystem.AddConstantMonomialVariable("maskElem")
# initialize libMesh data structures
eqnSystems.init()
# print info
eqnSystems.PrintSelf()
# setup imaging to interpolate onto FEM mesh
femImaging = femLibrary.PytttkImaging(getpot, dimensions, origin, spacing)
# Project imaging onto libMesh data structures
femImaging.ProjectImagingToFEMMesh("ElemImageMask", 0.0, imageDataVec,
eqnSystems)
femImaging.ProjectImagingToFEMMesh("StateSystem", 0.0, imageDataVec,
eqnSystems)
# create dirichlet nodes from this mask
numNodes = pennesSystem.PetscFEMSystemCreateNodeSetFromMask(
config.getfloat("labels", "vessel"), dirichletID)
print "# of dirichlet nodes %d" % numNodes
# get image label as numpy array
imageLabel = maskElemSystem.GetSolutionVector()[...]
#imageLabel = numpy.floor(10.0*imageLabel.copy())+1
k_0Label = imageLabel.copy()
w_0Label = imageLabel.copy()
mu_aLabel = imageLabel.copy()
mu_sLabel = imageLabel.copy()
for (idpos, label) in enumerate(imageLabel):
try:
tissueType = labelTable["%d" % int(label)]
except KeyError:
tissueType = "default"
labelCount[tissueType] = labelCount[tissueType] + 1
k_0Label[idpos] = k_0Table[tissueType]
w_0Label[idpos] = w_0Table[tissueType]
mu_aLabel[idpos] = mu_aTable[tissueType]
mu_sLabel[idpos] = mu_sTable[tissueType]
# create array of imaging data as petsc vec
k_0Vec = PETSc.Vec().createWithArray(k_0Label, comm=PETSc.COMM_SELF)
w_0Vec = PETSc.Vec().createWithArray(w_0Label, comm=PETSc.COMM_SELF)
mu_aVec = PETSc.Vec().createWithArray(mu_aLabel, comm=PETSc.COMM_SELF)
mu_sVec = PETSc.Vec().createWithArray(mu_sLabel, comm=PETSc.COMM_SELF)
# copy material properties to the system
eqnSystems.GetSystem("k_0").SetSolutionVector(k_0Vec)
eqnSystems.GetSystem("w_0").SetSolutionVector(w_0Vec)
eqnSystems.GetSystem("mu_a").SetSolutionVector(mu_aVec)
eqnSystems.GetSystem("mu_s").SetSolutionVector(mu_sVec)
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile, eqnSystems, 1, 0.0)
exodusII_IO.WriteParameterSystems(eqnSystems)
# setup IC
pennesSystem.PetscFEMSystemSetupInitialConditions()
# create list of laser positions
laserPositionList = [((.015, .015, 2 * spacing[2] + quadratureOffset),
(.018, .018, 2 * spacing[2] + quadratureOffset)),
((.015, .015, 2 * spacing[2] + quadratureOffset),
(.016, .018, 2 * spacing[2] + quadratureOffset)),
((.015, .015, 1 * spacing[2] + quadratureOffset),
(.014, .014, 1 * spacing[2] + quadratureOffset)),
((.015, .015, 1 * spacing[2] + quadratureOffset),
(.015, .018, 3 * spacing[2] + quadratureOffset))]
# time stamp
import pickle, time
timeStamp = 0
# set power id to turn laser on
pennesSystem.PetscFEMSystemUpdateTimeStep(1)
# loop over laser position and solve steady state equations for each position
#for (idpos,(pos0,pos1)) in enumerate(laserPositionList):
# loop and read new laser parameters
while (True):
if (os.path.getmtime(fem_params['ini_filename']) > timeStamp):
timeStamp = os.path.getmtime(fem_params['ini_filename'])
newIni = ConfigParser.SafeConfigParser({})
newIni.read(fem_params['ini_filename'])
laserParams = {}
laserParams['position1'] = [
newIni.getfloat("probe", varID)
for varID in ["x_0", "y_0", "z_0"]
]
laserParams['position2'] = [
newIni.getfloat("probe", varID)
for varID in ["x_1", "y_1", "z_1"]
]
print "laser position = ", newIni.getfloat("timestep",
"power"), laserParams
pennesSystem.PennesSDASystemUpdateLaserPower(
newIni.getfloat("timestep", "power"), 1)
pennesSystem.PennesSDASystemUpdateLaserPosition(
laserParams['position1'], laserParams['position2'])
pennesSystem.SystemSolve()
#fem.StoreTransientSystemTimeStep("StateSystem",timeID )
#exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, idpos+2, idpos*kwargs['deltat'])
exodusII_IO.WriteTimeStep(MeshOutputFile, eqnSystems, 2, 1.0)
exodusII_IO.WriteParameterSystems(eqnSystems)
# write to txt file
if (petscRank == 0):
time.sleep(1)
vtkExodusIIReader = vtk.vtkExodusIIReader()
print "opening %s " % MeshOutputFile
vtkExodusIIReader.SetFileName(MeshOutputFile)
vtkExodusIIReader.Update()
ntime = vtkExodusIIReader.GetNumberOfTimeSteps()
variableID = "u0"
print "ntime %d %s " % (ntime, variableID)
vtkExodusIIReader.SetTimeStep(1)
vtkExodusIIReader.SetPointResultArrayStatus(variableID, 1)
vtkExodusIIReader.Update()
curInput = None
# multi block
if vtkExodusIIReader.GetOutput().IsA("vtkMultiBlockDataSet"):
iter = vtkExodusIIReader.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
curInput = iter.GetCurrentDataObject()
else:
curInput = vtkExodusIIReader.GetOutput()
#fem_point_data= curInput.GetPointData().GetArray('u0')
#Soln=vtkNumPy.vtk_to_numpy(fem_point_data)
#numpy.savetxt( "temperature.txt" ,Soln)
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
# scale back to millimeter
# TODO verify that the data sets are registered in the native slicer coordinate system
# TODO segmented data MUST be read in with:
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([0.0, 0.0, 0.0])
AffineTransform.RotateZ(0.0)
AffineTransform.RotateY(0.0)
AffineTransform.RotateX(0.0)
AffineTransform.Scale([1000., 1000., 1000.])
# scale to millimeter
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(curInput)
transformFilter.SetTransform(AffineTransform)
transformFilter.Update()
# setup contour filter
vtkContour = vtk.vtkContourFilter()
vtkContour.SetInput(transformFilter.GetOutput())
# TODO: not sure why this works...
# set the array to process at the temperature == u0
vtkContour.SetInputArrayToProcess(0, 0, 0, 0, 'u0')
contourValuesList = eval(newIni.get('exec', 'contours'))
vtkContour.SetNumberOfContours(len(contourValuesList))
print "plotting array:", vtkContour.GetArrayComponent()
for idContour, contourValue in enumerate(contourValuesList):
print "plotting contour:", idContour, contourValue
vtkContour.SetValue(idContour, contourValue)
vtkContour.Update()
# setup threshold filter
vtkThreshold = vtk.vtkThreshold()
vtkThreshold.SetInput(transformFilter.GetOutput())
vtkThreshold.ThresholdByLower(contourValuesList[0])
#vtkThreshold.SetSelectedComponent( 0 )
vtkThreshold.SetComponentModeToUseAny()
vtkThreshold.Update()
# resample onto image
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput(vtkImageMask)
vtkResample.SetSource(vtkThreshold.GetOutput())
vtkResample.Update()
# write output
print "writing fem.vtk "
vtkImageWriter = vtk.vtkDataSetWriter()
vtkImageWriter.SetFileTypeToBinary()
vtkImageWriter.SetFileName("fem.vtk")
vtkImageWriter.SetInput(vtkResample.GetOutput())
vtkImageWriter.Update()
# write stl file
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetInput(vtkContour.GetOutput())
stlWriter.SetFileName("fem.stl")
stlWriter.SetFileTypeToBinary()
stlWriter.Write()
# write support file to signal full stl file is written
# Slicer module will wait for this file to be written
# before trying to open stl file to avoid incomplete reads
with open('./fem.finish', 'w') as signalFile:
signalFile.write("the stl file has been written\n")
else:
print "waiting on user input.."
# echo lookup table
if (petscRank == 0):
print "lookup tables"
print "labeled %d voxels" % len(imageLabel)
print "labels", labelTable
print "counts", labelCount
print "conductivity", k_0Table
print "perfusion", w_0Table
print "absorption", mu_aTable
print "scattering", mu_sTable
time.sleep(2)
femImaging.ProjectImagingToFEMMesh("Background",0.0,v2,eqnSystems)
femImaging.ProjectImagingToFEMMesh("ImageMask" ,0.0,v3,eqnSystems)
bgSystem.SystemSolve( )
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, timeID+1, timeID )
# FIXME: The FEM ordering does not match the imaging
# FIXME: Need to use exodus file for now
# write numpy to disk in matlab
fem_orig_array = origSystem.GetSolutionVector( )[...]
fem_drop_array = bgSystem.GetSolutionVector( )[...]
fem_mask_array = maskSystem.GetSolutionVector( )[...]
scipyio.savemat("Processed/background.%04d.mat"%(timeID), {'pixelsize':npixelROI, 'original':fem_orig_array , 'drop':fem_drop_array , 'mask':fem_mask_array } )
# write numpy to vtk
ROIOrigin = (xbounds[0],ybounds[0],zbounds[0])
vtkOrigImage = ConvertNumpyVTKImage(fem_orig_array, "orig" , npixelROI, ROIOrigin )
vtkOrigWriter = vtk.vtkDataSetWriter()
vtkOrigWriter.SetFileName("Processed/original.%04d.vtk" % timeID )
vtkOrigWriter.SetInput( vtkOrigImage )
vtkOrigWriter.Update()
vtkDropImage = ConvertNumpyVTKImage(fem_drop_array, "drop" , npixelROI, ROIOrigin )
vtkDropWriter = vtk.vtkDataSetWriter()
vtkDropWriter.SetFileName("Processed/drop.%04d.vtk" % timeID )
vtkDropWriter.SetInput( vtkDropImage )
vtkDropWriter.Update()
## FIXME: bug putting data back into imaging data structures
## # get libMesh Background Solution as numpy data structure
## maxwell_data = phase_curr.copy()
## # reshape from colume major Fortran-like storage
## maxwell_data[ROI[0][0]+0:ROI[0][1]+0,
pts.InsertPoint(c, i,j,k)
c += 1
scalars = vtk.vtkFloatArray()
scalars.SetNumberOfTuples(n**3)
for i in xrange(int(n**3/3.)): scalars.SetTuple1(i,.1)
for i in xrange(int(n**3/3.), int(2*(n**3)/3.)): scalars.SetTuple1(i,.5)
for i in xrange(int(2*(n**3)/3.), int(n**3)): scalars.SetTuple1(i,.9)
# Wrap as a structured grid even though the data is not.
sg = vtk.vtkStructuredGrid()
sg.GetPointData().SetScalars(scalars)
sg.SetPoints(pts)
sg.SetDimensions(n,n,n)
w = vtk.vtkDataSetWriter()
w.SetFileTypeToASCII()
w.SetFileName('tmp-sgrid.vtk')
w.SetInput(sg)
w.Write()
w.Update()
geom = vtk.vtkStructuredGridGeometryFilter()
geom.SetInput(sg)
geom.Update()
m = vtk.vtkPolyDataMapper()
m.SetInput(geom.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
LandmarkTransform = vtk.vtkLandmarkTransform()
LandmarkTransform.SetSourceLandmarks(SourceLMReader.GetOutput().GetPoints() )
LandmarkTransform.SetTargetLandmarks(TargetLMReader.GetOutput().GetPoints() )
LandmarkTransform.SetModeToRigidBody()
LandmarkTransform.Update()
print LandmarkTransform.GetMatrix()
# apply transform
transformFilter = vtk.vtkTransformFilter()
#transformFilter.SetInput(vtkCylinder.GetOutput() )
transformFilter.SetInput(trianglefilter.GetOutput() )
transformFilter.SetTransform( LandmarkTransform)
transformFilter.Update()
# write model
modelWriter = vtk.vtkDataSetWriter()
modelWriter.SetInput(transformFilter.GetOutput())
modelWriter.SetFileName("needle.vtk")
modelWriter.SetFileTypeToBinary()
modelWriter.Update()
# read image/ROI
ImageReader = vtk.vtkDataSetReader()
ImageReader.SetFileName("newimage.vtk")
ImageReader.Update()
# resample needle to image to create mask
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( ImageReader.GetOutput() )
vtkResample.SetSource( transformFilter.GetOutput() )
vtkResample.Update()
def ProjectImagingMesh(ini_file):
import vtk.util.numpy_support as vtkNumPy
import ConfigParser
import scipy.io as scipyio
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# read config file
config = ConfigParser.ConfigParser()
config.add_section("imaging")
config.add_section("fem")
config.set("imaging","listoffset","[0]")
config.read(ini_file)
# get work directory
work_dir = config.get('fem','work_dir')
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
RotateX = float(config.get('fem','rotatex'))
RotateY = float(config.get('fem','rotatey'))
RotateZ = float(config.get('fem','rotatez'))
Translate = eval(config.get('fem','translate'))
Scale = eval(config.get('fem','scale'))
print "rotate", RotateX , RotateY , RotateZ ,"translate", Translate, "scale", Scale
# read imaging data geometry that will be used to project FEM data onto
dimensions = eval(config.get('imaging','dimensions'))
spacing = eval(config.get('imaging','spacing'))
origin = eval(config.get('imaging','origin'))
print spacing, origin, dimensions
templateImage = CreateVTKImage(dimensions,spacing,origin)
# write template image for position verification
vtkTemplateWriter = vtk.vtkDataSetWriter()
vtkTemplateWriter.SetFileName( "%s/imageTemplate.vtk" % work_dir )
vtkTemplateWriter.SetInput( templateImage )
vtkTemplateWriter.Update()
#setup to interpolate at 5 points across axial dimension
TransformList = []
listoffset = eval(config.get('imaging','listoffset'))
naverage = len(listoffset)
try:
subdistance = spacing[2] / (naverage-1)
except ZeroDivisionError:
subdistance = 0.0 # default is not to offset
print "listoffset",listoffset, "subspacing distance = ", subdistance
for idtransform in listoffset:
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate( Translate[0],Translate[1],
Translate[2] + subdistance*idtransform )
AffineTransform.RotateZ( RotateZ )
AffineTransform.RotateY( RotateY )
AffineTransform.RotateX( RotateX )
AffineTransform.Scale( Scale )
TransformList.append( AffineTransform )
#laserTip = AffineTransform.TransformPoint( laserTip )
#laserOrientation = AffineTransform.TransformVector( laserOrientation )
# Interpolate FEM onto imaging data structures
vtkExodusIIReader = vtk.vtkExodusIIReader()
#vtkExodusIIReader.SetFileName( "%s/fem_stats.e" % work_dir )
#vtkExodusIIReader.SetPointResultArrayStatus("Mean0",1)
#vtkExodusIIReader.SetPointResultArrayStatus("StdDev0",1)
#Timesteps = 120
meshFileList = eval(config.get('fem','mesh_files'))
print meshFileList
for mesh_filename in meshFileList:
vtkExodusIIReader.SetFileName( "%s/%s" % (work_dir,mesh_filename) )
#vtkExodusIIReader.SetPointResultArrayStatus("Vard0Mean",1)
#vtkExodusIIReader.SetPointResultArrayStatus("Vard0Kurt",1)
vtkExodusIIReader.Update()
numberofresultarrays = vtkExodusIIReader.GetNumberOfPointResultArrays()
print numberofresultarrays
for resultarrayindex in range(numberofresultarrays):
resultarrayname = vtkExodusIIReader.GetPointResultArrayName(resultarrayindex)
vtkExodusIIReader.SetPointResultArrayStatus( "%s" % (resultarrayname),1)
print resultarrayname
vtkExodusIIReader.Update()
ntime = vtkExodusIIReader.GetNumberOfTimeSteps()
#print ntime
#for timeID in range(69,70):
for timeID in range(ntime):
vtkExodusIIReader.SetTimeStep(timeID)
vtkExodusIIReader.Update()
# reflect
vtkReflectX = vtk.vtkReflectionFilter()
vtkReflectX.SetPlaneToXMin()
vtkReflectX.SetInput( vtkExodusIIReader.GetOutput() )
vtkReflectX.Update()
# reflect
vtkReflectY = vtk.vtkReflectionFilter()
vtkReflectY.SetPlaneToYMax()
vtkReflectY.SetInput( vtkReflectX.GetOutput() )
vtkReflectY.Update()
# apply the average of the transform
mean_array = numpy.zeros(dimensions[0]*dimensions[1]*dimensions[2])
std_array = numpy.zeros(dimensions[0]*dimensions[1]*dimensions[2])
for affineFEMTranform in TransformList:
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = affineFEMTranform.GetConcatenatedTransform(0).GetMatrix()
#print matrix
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
#print RotationMatrix
print Translation
TransformedFEMMesh = None
if vtkReflectY.GetOutput().IsA("vtkMultiBlockDataSet"):
AppendBlocks = vtk.vtkAppendFilter()
iter = vtkReflectY.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
# loop over blocks...
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( affineFEMTranform )
vtkTransformFEMMesh.SetInput( curInput )
vtkTransformFEMMesh.Update()
AppendBlocks.AddInput( vtkTransformFEMMesh.GetOutput() )
AppendBlocks.Update( )
iter.GoToNextItem();
TransformedFEMMesh = AppendBlocks.GetOutput()
else:
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( affineFEMTranform )
vtkTransformFEMMesh.SetInput( vtkReflectY.GetOutput() )
vtkTransformFEMMesh.Update()
TransformedFEMMesh = vtkTransformFEMMesh.GetOutput()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( templateImage )
vtkResample.SetSource( TransformedFEMMesh )
vtkResample.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
#meantmp = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Mean'))
#print meantmp.max()
#mean_array = mean_array + vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Mean'))
#std_array = std_array + vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Vard0Kurt'))
#print fem_array
#print type(fem_array )
# average
#mean_array = mean_array/naverage
#print mean_array.max()
#std_array = std_array /naverage
# write numpy to disk in matlab
#scipyio.savemat("%s/modelstats.navg%d.%04d.mat" % (work_dir,naverage,timeID), {'spacing':spacing, 'origin':origin,'Vard0Mean':mean_array,'Vard0Kurt':std_array })
# write output
print "writing ", timeID, mesh_filename, work_dir
vtkStatsWriter = vtk.vtkDataSetWriter()
vtkStatsWriter.SetFileTypeToBinary()
vtkStatsWriter.SetFileName("%s/modelstats.navg%d.%s.%04d.vtk"%(work_dir,naverage,mesh_filename,timeID))
vtkStatsWriter.SetInput(vtkResample.GetOutput())
vtkStatsWriter.Update()
def GetRawDICOMData(self, idtime, outDirectoryID):
# loop until files are ready to be read in
realImageFilenames = []
imagImageFilenames = []
# FIXME: index fun, slice start from 0, echo start from 1
for idslice in range(self.nslice):
for idecho in range(1, self.NumberEcho + 1):
realImageFilenames.append(
self.QueryDictionary(idtime, idecho, idslice, 2))
imagImageFilenames.append(
self.QueryDictionary(idtime, idecho, idslice, 3))
#create local vars
rootdir = self.dataDirectory
dim = self.dimensions
real_array = numpy.zeros(self.FullSize, dtype=numpy.float32)
imag_array = numpy.zeros(self.FullSize, dtype=numpy.float32)
vtkAppendReal = vtk.vtkImageAppendComponents()
vtkAppendImag = vtk.vtkImageAppendComponents()
for idEchoLoc, (fileNameReal, fileNameImag) in enumerate(
zip(realImageFilenames, imagImageFilenames)):
# FIXME: index nightmare
# FIXME: will be wrong for different ordering
# arrange such that echo varies fast then x, then y, then z
# example of how slicing behaves
#>>> x = range(100)
#>>> x
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
#>>> x[0:100:10]
#[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
#>>> x[1:100:10]
#[1, 11, 21, 31, 41, 51, 61, 71, 81, 91]
#>>> x[2:100:10]
#[2, 12, 22, 32, 42, 52, 62, 72, 82, 92]
#>>> x[3:100:10]
#[3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
idEcho = idEchoLoc % dim[3]
idSlice = idEchoLoc / dim[3]
beginIndex = dim[0] * dim[1] * dim[3] * idSlice + idEcho
finalIndex = dim[0] * dim[1] * dim[3] * (idSlice + 1)
stepIndex = dim[3]
## realds = dicom.read_file( "%s/%s"%(rootdir,fileNameReal) )
## imagds = dicom.read_file( "%s/%s"%(rootdir,fileNameImag) )
## realsliceID = int( round((float(realds.SliceLocation) - float(realds[0x0019,0x1019].value))/ realds.SliceThickness))
## imagsliceID = int( round((float(imagds.SliceLocation) - float(imagds[0x0019,0x1019].value))/ imagds.SliceThickness))
## print "%03d echo %03d slice %03d slice [%d:%d:%d] %03d %s %03d %s "% (idEchoLoc,idEcho,idSlice,beginIndex,finalIndex,stepIndex,realsliceID,fileNameReal,imagsliceID,fileNameImag )
vtkRealDcmReader = vtk.vtkDICOMImageReader()
vtkRealDcmReader.SetFileName("%s/%s" % (rootdir, fileNameReal))
vtkRealDcmReader.Update()
vtkRealData = vtk.vtkImageCast()
vtkRealData.SetOutputScalarTypeToFloat()
vtkRealData.SetInput(vtkRealDcmReader.GetOutput())
vtkRealData.Update()
real_image = vtkRealData.GetOutput().GetPointData()
real_array[
beginIndex:finalIndex:stepIndex] = vtkNumPy.vtk_to_numpy(
real_image.GetArray(0))
vtkImagDcmReader = vtk.vtkDICOMImageReader()
vtkImagDcmReader.SetFileName("%s/%s" % (rootdir, fileNameImag))
vtkImagDcmReader.Update()
vtkImagData = vtk.vtkImageCast()
vtkImagData.SetOutputScalarTypeToFloat()
vtkImagData.SetInput(vtkImagDcmReader.GetOutput())
vtkImagData.Update()
imag_image = vtkImagData.GetOutput().GetPointData()
imag_array[
beginIndex:finalIndex:stepIndex] = vtkNumPy.vtk_to_numpy(
imag_image.GetArray(0))
vtkAppendReal.SetInput(idEchoLoc, vtkRealDcmReader.GetOutput())
vtkAppendImag.SetInput(idEchoLoc, vtkImagDcmReader.GetOutput())
vtkAppendReal.Update()
vtkAppendImag.Update()
vtkRealDcmWriter = vtk.vtkDataSetWriter()
vtkRealDcmWriter.SetFileName("Processed/%s/realrawdata.%04d.vtk" %
(outDirectoryID, idtime))
vtkRealDcmWriter.SetInput(vtkAppendReal.GetOutput())
vtkRealDcmWriter.Update()
vtkImagDcmWriter = vtk.vtkDataSetWriter()
vtkImagDcmWriter.SetFileName("Processed/%s/imagrawdata.%04d.vtk" %
(outDirectoryID, idtime))
vtkImagDcmWriter.SetInput(vtkAppendImag.GetOutput())
vtkImagDcmWriter.Update()
# write numpy to disk in matlab
echoTimes = []
for idecho in range(1, self.NumberEcho + 1):
localKey = self.keyTemplate % (idtime, idecho, 0, 2)
echoTimes.append(self.DicomDataDictionary[localKey][1])
scipyio.savemat(
"Processed/%s/rawdata.%04d.mat" % (outDirectoryID, idtime), {
'dimensions': dim,
'echoTimes': echoTimes,
'real': real_array,
'imag': imag_array
})
# end GetRawDICOMData
return (real_array, imag_array)
def pennesModeling(**kwargs):
"""
treatment planning model
"""
# import needed modules
import petsc4py, numpy, sys
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
from petsc4py import PETSc
# break processors into separate communicators
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# the original configuration ini file should be stored
config = kwargs['config_parser']
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# copy all values from the input file
for section in config.sections():
for name,value in config.items(section):
#print "%s/%s" % (section,name) , value
getpot.SetIniValue( "%s/%s" % (section,name) , value )
# nodeset 1 will be treated as dirichlet
dirichletID = 1
getpot.SetIniValue( "bc/u_dirichlet" , '%d' % dirichletID )
# set tissue lookup tables
k_0Table = {"default":config.getfloat("thermal_conductivity","k_0_healthy") ,
"vessel" :config.getfloat("thermal_conductivity","k_0_healthy") ,
"grey" :config.getfloat("thermal_conductivity","k_0_grey" ) ,
"white" :config.getfloat("thermal_conductivity","k_0_white" ) ,
"csf" :config.getfloat("thermal_conductivity","k_0_csf" ) ,
"tumor" :config.getfloat("thermal_conductivity","k_0_tumor" ) }
w_0Table = {"default":config.getfloat("perfusion","w_0_healthy") ,
"vessel" :config.getfloat("perfusion","w_0_healthy") ,
"grey" :config.getfloat("perfusion","w_0_grey" ) ,
"white" :config.getfloat("perfusion","w_0_white" ) ,
"csf" :config.getfloat("perfusion","w_0_csf" ) ,
"tumor" :config.getfloat("perfusion","w_0_tumor" ) }
mu_aTable = {"default":config.getfloat("optical","mu_a_healthy") ,
"vessel" :config.getfloat("optical","mu_a_healthy") ,
"grey" :config.getfloat("optical","mu_a_grey" ) ,
"white" :config.getfloat("optical","mu_a_white" ) ,
"csf" :config.getfloat("optical","mu_a_csf" ) ,
"tumor" :config.getfloat("optical","mu_a_tumor" ) }
mu_sTable = {"default":config.getfloat("optical","mu_s_healthy") ,
"vessel" :config.getfloat("optical","mu_s_healthy") ,
"grey" :config.getfloat("optical","mu_s_grey" ) ,
"white" :config.getfloat("optical","mu_s_white" ) ,
"csf" :config.getfloat("optical","mu_s_csf" ) ,
"tumor" :config.getfloat("optical","mu_s_tumor" ) }
labelTable= {config.get("labels","greymatter" ):"grey" ,
config.get("labels","whitematter"):"white",
config.get("labels","csf" ):"csf" ,
config.get("labels","tumor" ):"tumor",
config.get("labels","vessel" ):"vessel"}
labelCount= {"default":0,
"grey" :0,
"white" :0,
"csf" :0,
"tumor" :0,
"vessel" :0}
# imaging params
import vtk
import vtk.util.numpy_support as vtkNumPy
SegmentFile=config.get("exec","segment_file")
# set the default reader based on extension
if( SegmentFile.split(".").pop() == "vtk"):
vtkImageReader = vtk.vtkDataSetReader
elif( SegmentFile.split(".").pop() == "vti"):
vtkImageReader = vtk.vtkXMLImageDataReader
else:
raise RuntimeError("uknown file")
# get dimension info from header
vtkSetupReader = vtkImageReader()
vtkSetupReader.SetFileName(SegmentFile )
vtkSetupReader.Update()
vtkImageMask = vtkSetupReader.GetOutput()
dimensions = vtkSetupReader.GetOutput().GetDimensions()
numberPointsImage = vtkSetupReader.GetOutput().GetNumberOfPoints()
spacing_mm = vtkSetupReader.GetOutput().GetSpacing()
origin_mm = vtkSetupReader.GetOutput().GetOrigin()
# convert to meters
spacing = [dx*.001 for dx in spacing_mm]
origin = [x0*.001 for x0 in origin_mm]
# pass pointer to c++
image_cells = vtkImageMask.GetPointData()
data_array = vtkNumPy.vtk_to_numpy( image_cells.GetArray(0) )
# need to pass numpy array's w/ Fortran storage... ie painful to debug
imageDataVec = PETSc.Vec().createWithArray(numpy.ravel(data_array,order='F'), comm=PETSc.COMM_SELF)
# FIXME - center around quadrature in out-of-plane direction
# FIXME - need better out of plane cooling model
quadratureOffset = 1./numpy.sqrt(3.0) * spacing[2]/2.0
# expecting roi and subsample of the form:
# roi = [(40,210),(30,220),(6,78)]
# subsample = [3,3,2]
ROI = eval(config.get('exec','roi'))
subsample = eval(config.get('exec','subsample'))
nelemROI = [ (pixel[1] - pixel[0] - 1 )/sub for pixel,sub in zip(ROI,subsample)]
xbounds = [ origin[0]+spacing[0]*(ROI[0][0]+0.5),origin[0]+spacing[0]*(ROI[0][1]+0.5) ]
ybounds = [ origin[1]+spacing[1]*(ROI[1][0]+0.5),origin[1]+spacing[1]*(ROI[1][1]+0.5) ]
zbounds = [ origin[2]+spacing[2]*(ROI[2][0]+0.5),origin[2]+spacing[2]*(ROI[2][1]+0.5) ]
if( petscRank ==0 ):
print "#points",numberPointsImage , "dimensions ",dimensions , "spacing ",spacing , "origin ",origin
print "ROI",ROI , "nelemROI ",nelemROI , "bounds", xbounds, ybounds, zbounds
#set to steady state solve
getpot.SetIniValue("steadystate/domain_0","true")
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
#femMesh.SetupUnStructuredGrid(kwargs['mesh_file'],0,RotationMatrix, Translation )
#femMesh.ReadFile(kwargs['mesh_file'])
femMesh.SetupStructuredGrid(nelemROI,xbounds,ybounds,zbounds,
[2,2,2,2,2,2])
# get output file name else set default name
try:
MeshOutputFile = config.get("exec","exodus_file" )
except ConfigParser.NoOptionError:
MeshOutputFile = "fem.e"
# add the data structures for the Background System Solve
# set deltat, number of time steps, power profile, and add system
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#getpot.SetIniPower(1,[[19,119],[90.0,100.0]] )
getpot.SetIniPower(1,kwargs['powerHistory'] )
# AddPennesSDASystem
# AddPennesRFSystem
# AddPennesDeltaPSystem
pennesSystem = eval("eqnSystems.%s('StateSystem',kwargs['deltat'])" % kwargs['physics'])
pennesSystem.AddStorageVectors( kwargs['ntime']+1 )
# add system for labels
# FIXME: need both nodal, for dirichlet bc, and element version, for parameter masks
maskElemSystem = eqnSystems.AddExplicitSystem( "ElemImageMask" )
maskElemSystem.AddConstantMonomialVariable( "maskElem" )
# initialize libMesh data structures
eqnSystems.init( )
# print info
eqnSystems.PrintSelf()
# setup imaging to interpolate onto FEM mesh
femImaging = femLibrary.PytttkImaging(getpot, dimensions ,origin,spacing)
# Project imaging onto libMesh data structures
femImaging.ProjectImagingToFEMMesh("ElemImageMask" ,0.0,imageDataVec,eqnSystems)
femImaging.ProjectImagingToFEMMesh("StateSystem" ,0.0,imageDataVec,eqnSystems)
# create dirichlet nodes from this mask
numNodes = pennesSystem.PetscFEMSystemCreateNodeSetFromMask(config.getfloat("labels","vessel"),dirichletID)
print "# of dirichlet nodes %d" %numNodes
# get image label as numpy array
imageLabel = maskElemSystem.GetSolutionVector()[...]
#imageLabel = numpy.floor(10.0*imageLabel.copy())+1
k_0Label = imageLabel.copy()
w_0Label = imageLabel.copy()
mu_aLabel = imageLabel.copy()
mu_sLabel = imageLabel.copy()
for (idpos,label) in enumerate(imageLabel):
try:
tissueType = labelTable["%d"%int(label)]
except KeyError:
tissueType = "default"
labelCount[tissueType] = labelCount[tissueType] + 1
k_0Label[ idpos] = k_0Table[ tissueType]
w_0Label[ idpos] = w_0Table[ tissueType]
mu_aLabel[idpos] = mu_aTable[tissueType]
mu_sLabel[idpos] = mu_sTable[tissueType]
# create array of imaging data as petsc vec
k_0Vec = PETSc.Vec().createWithArray(k_0Label , comm=PETSc.COMM_SELF)
w_0Vec = PETSc.Vec().createWithArray(w_0Label , comm=PETSc.COMM_SELF)
mu_aVec = PETSc.Vec().createWithArray(mu_aLabel, comm=PETSc.COMM_SELF)
mu_sVec = PETSc.Vec().createWithArray(mu_sLabel, comm=PETSc.COMM_SELF)
# copy material properties to the system
eqnSystems.GetSystem("k_0").SetSolutionVector( k_0Vec )
eqnSystems.GetSystem("w_0").SetSolutionVector( w_0Vec )
eqnSystems.GetSystem("mu_a").SetSolutionVector(mu_aVec)
eqnSystems.GetSystem("mu_s").SetSolutionVector(mu_sVec)
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
exodusII_IO.WriteParameterSystems(eqnSystems)
# setup IC
pennesSystem.PetscFEMSystemSetupInitialConditions( )
# create list of laser positions
laserPositionList = [ ((.015,.015,2*spacing[2]+quadratureOffset),
(.018,.018,2*spacing[2]+quadratureOffset) ),
((.015,.015,2*spacing[2]+quadratureOffset),
(.016,.018,2*spacing[2]+quadratureOffset) ),
((.015,.015,1*spacing[2]+quadratureOffset),
(.014,.014,1*spacing[2]+quadratureOffset) ),
((.015,.015,1*spacing[2]+quadratureOffset),
(.015,.018,3*spacing[2]+quadratureOffset) )]
# time stamp
import pickle,time
timeStamp =0
# set power id to turn laser on
pennesSystem.PetscFEMSystemUpdateTimeStep( 1 )
# loop over laser position and solve steady state equations for each position
#for (idpos,(pos0,pos1)) in enumerate(laserPositionList):
# loop and read new laser parameters
while(True):
if(os.path.getmtime(fem_params['ini_filename']) > timeStamp):
timeStamp = os.path.getmtime(fem_params['ini_filename'] )
newIni = ConfigParser.SafeConfigParser({})
newIni.read(fem_params['ini_filename'])
laserParams = {}
laserParams['position1'] = [newIni.getfloat("probe",varID ) for varID in ["x_0","y_0","z_0"] ]
laserParams['position2'] = [newIni.getfloat("probe",varID ) for varID in ["x_1","y_1","z_1"] ]
print "laser position = ", newIni.getfloat("timestep","power") , laserParams
pennesSystem.PennesSDASystemUpdateLaserPower(newIni.getfloat("timestep","power"),1)
pennesSystem.PennesSDASystemUpdateLaserPosition(laserParams['position1'],laserParams['position2'])
pennesSystem.SystemSolve( )
#fem.StoreTransientSystemTimeStep("StateSystem",timeID )
#exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, idpos+2, idpos*kwargs['deltat'])
exodusII_IO.WriteTimeStep(MeshOutputFile ,eqnSystems, 2, 1.0)
exodusII_IO.WriteParameterSystems(eqnSystems)
# write to txt file
if( petscRank ==0 ):
time.sleep(1)
vtkExodusIIReader = vtk.vtkExodusIIReader()
print "opening %s " % MeshOutputFile
vtkExodusIIReader.SetFileName( MeshOutputFile )
vtkExodusIIReader.Update()
ntime = vtkExodusIIReader.GetNumberOfTimeSteps()
variableID = "u0"
print "ntime %d %s " % (ntime,variableID)
vtkExodusIIReader.SetTimeStep(1)
vtkExodusIIReader.SetPointResultArrayStatus(variableID,1)
vtkExodusIIReader.Update()
curInput = None
# multi block
if vtkExodusIIReader.GetOutput().IsA("vtkMultiBlockDataSet"):
iter = vtkExodusIIReader.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
curInput = iter.GetCurrentDataObject()
else:
curInput = vtkExodusIIReader.GetOutput()
#fem_point_data= curInput.GetPointData().GetArray('u0')
#Soln=vtkNumPy.vtk_to_numpy(fem_point_data)
#numpy.savetxt( "temperature.txt" ,Soln)
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
# scale back to millimeter
# TODO verify that the data sets are registered in the native slicer coordinate system
# TODO segmented data MUST be read in with:
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
# TODO add data -> volume -> show options -> ignore orientation
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([ 0.0,0.0,0.0])
AffineTransform.RotateZ( 0.0 )
AffineTransform.RotateY( 0.0 )
AffineTransform.RotateX( 0.0 )
AffineTransform.Scale([1000.,1000.,1000.])
# scale to millimeter
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInput(curInput)
transformFilter.SetTransform(AffineTransform)
transformFilter.Update()
# setup contour filter
vtkContour = vtk.vtkContourFilter()
vtkContour.SetInput( transformFilter.GetOutput() )
# TODO: not sure why this works...
# set the array to process at the temperature == u0
vtkContour.SetInputArrayToProcess(0,0,0,0,'u0')
contourValuesList = eval(newIni.get('exec','contours'))
vtkContour.SetNumberOfContours( len(contourValuesList ) )
print "plotting array:", vtkContour.GetArrayComponent( )
for idContour,contourValue in enumerate(contourValuesList):
print "plotting contour:",idContour,contourValue
vtkContour.SetValue( idContour,contourValue )
vtkContour.Update( )
# setup threshold filter
vtkThreshold = vtk.vtkThreshold()
vtkThreshold.SetInput( transformFilter.GetOutput() )
vtkThreshold.ThresholdByLower( contourValuesList[0] )
#vtkThreshold.SetSelectedComponent( 0 )
vtkThreshold.SetComponentModeToUseAny( )
vtkThreshold.Update()
# resample onto image
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( vtkImageMask )
vtkResample.SetSource( vtkThreshold.GetOutput() )
vtkResample.Update()
# write output
print "writing fem.vtk "
vtkImageWriter = vtk.vtkDataSetWriter()
vtkImageWriter.SetFileTypeToBinary()
vtkImageWriter.SetFileName("fem.vtk")
vtkImageWriter.SetInput(vtkResample.GetOutput())
vtkImageWriter.Update()
# write stl file
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetInput(vtkContour.GetOutput( ))
stlWriter.SetFileName("fem.stl")
stlWriter.SetFileTypeToBinary()
stlWriter.Write()
# write support file to signal full stl file is written
# Slicer module will wait for this file to be written
# before trying to open stl file to avoid incomplete reads
with open('./fem.finish', 'w') as signalFile:
signalFile.write("the stl file has been written\n")
else:
print "waiting on user input.."
# echo lookup table
if( petscRank ==0 ):
print "lookup tables"
print "labeled %d voxels" % len(imageLabel)
print "labels" , labelTable
print "counts" , labelCount
print "conductivity", k_0Table
print "perfusion" , w_0Table
print "absorption" , mu_aTable
print "scattering" , mu_sTable
time.sleep(2)
#
# generate tensors
ptLoad = vtk.vtkPointLoad()
ptLoad.SetLoadValue(100.0)
ptLoad.SetSampleDimensions(20, 20, 20)
ptLoad.ComputeEffectiveStressOn()
ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10)
#
# If the current directory is writable, then test the writers
#
try:
channel = open("wSP.vtk", "wb")
channel.close()
wSP = vtk.vtkDataSetWriter()
wSP.SetInputConnection(ptLoad.GetOutputPort())
wSP.SetFileName("wSP.vtk")
wSP.SetTensorsName("pointload")
wSP.SetScalarsName("effective_stress")
wSP.Write()
rSP = vtk.vtkDataSetReader()
rSP.SetFileName("wSP.vtk")
rSP.SetTensorsName("pointload")
rSP.SetScalarsName("effective_stress")
rSP.Update()
input = rSP.GetOutput()
# cleanup
def ProjectImagingMesh(fem_mesh_file):
import vtk
import vtk.util.numpy_support as vtkNumPy
import scipy.io as scipyio
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform = vtk.vtkTransform()
# should be in meters
AffineTransform.Translate(.0000001,.0000001,.0000001)
AffineTransform.RotateZ( 0 )
AffineTransform.RotateY( 0 )
AffineTransform.RotateX( 0 )
AffineTransform.Scale([1.,1.,1.])
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = AffineTransform.GetConcatenatedTransform(0).GetMatrix()
#print matrix
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
#print RotationMatrix ,Translation
#laserTip = AffineTransform.TransformPoint( laserTip )
#laserOrientation = AffineTransform.TransformVector( laserOrientation )
# read imaging data geometry that will be used to project FEM data onto
#vtkReader = vtk.vtkXMLImageDataReader()
vtkReader = vtk.vtkDataSetReader()
#vtkReader.SetFileName('/data/cjmaclellan/mdacc/nano/spio/spioVTK/67_11/tmap_67_11.0000.vtk' )
vtkReader.SetFileName('/data/cjmaclellan/mdacc/deltap_phantom_oct10/VTKtmaps/S695/S695.0000.vtk' )
#vtkReader.SetFileName('/data/cjmaclellan/mdacc/nano/nrtmapsVTK/R695/R695.0000.vtk' )
vtkReader.Update()
templateImage = vtkReader.GetOutput()
dimensions = templateImage.GetDimensions()
spacing = templateImage.GetSpacing()
origin = templateImage.GetOrigin()
print spacing, origin, dimensions
#fem.SetImagingDimensions( dimensions ,origin,spacing)
## project imaging onto fem mesh
#if (vtk != None):
# vtkImageReader = vtk.vtkDataSetReader()
# vtkImageReader.SetFileName('/data/fuentes/mdacc/uqModelStudy/dog1_980/temperature.%04d.vtk' % timeID )
# vtkImageReader.Update()
# image_cells = vtkImageReader.GetOutput().GetPointData()
# data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
# v1 = PETSc.Vec().createWithArray(data_array, comm=PETSc.COMM_SELF)
# fem.ProjectImagingToFEMMesh("MRTI", v1)
# fem.StoreSystemTimeStep("MRTI",timeID )
#
# # extract voi for QOI
# vtkVOIExtract = vtk.vtkExtractVOI()
# vtkVOIExtract.SetInput( vtkImageReader.GetOutput() )
# VOI = [10,100,100,150,0,0]
# vtkVOIExtract.SetVOI( VOI )
# vtkVOIExtract.Update()
# mrti_point_data= vtkVOIExtract.GetOutput().GetPointData()
# mrti_array = vtkNumPy.vtk_to_numpy(mrti_point_data.GetArray('scalars'))
# #print mrti_array
# #print type(mrti_array)
# Interpolate FEM onto imaging data structures
vtkExodusIIReader = vtk.vtkExodusIIReader()
vtkExodusIIReader.SetFileName( fem_mesh_file )
vtkExodusIIReader.SetPointResultArrayStatus("u0",1)
vtkExodusIIReader.SetPointResultArrayStatus("u0*",1)
vtkExodusIIReader.SetPointResultArrayStatus("u1",1)
matsize = int(dimensions[1])#get matrix size
#preallocate size of arrays
u0_array_1 = scipy.zeros((matsize,matsize))
u0_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
u1_array_1 = scipy.zeros((matsize,matsize))
u1_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
u0star_array_1 = scipy.zeros((matsize,matsize))
u0star_array_2 = scipy.zeros((matsize,matsize,ntime*nsubstep))
#for timeID in range(1,2):
for timeID in range(1,ntime*nsubstep):
vtkExodusIIReader.SetTimeStep(timeID-1)
vtkExodusIIReader.Update()
# apply the transform
TransformedFEMMesh = None
if vtkExodusIIReader.GetOutput().IsA("vtkMultiBlockDataSet"):
AppendBlocks = vtk.vtkAppendFilter()
iter = vtkExodusIIReader.GetOutput().NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
# loop over blocks...
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( AffineTransform )
vtkTransformFEMMesh.SetInput( curInput )
vtkTransformFEMMesh.Update()
AppendBlocks.AddInput( vtkTransformFEMMesh.GetOutput() )
AppendBlocks.Update( )
iter.GoToNextItem();
TransformedFEMMesh = AppendBlocks.GetOutput()
else:
vtkTransformFEMMesh = vtk.vtkTransformFilter()
vtkTransformFEMMesh.SetTransform( AffineTransform )
vtkTransformFEMMesh.SetInput( vtkExodusIIReader.GetOutput() )
vtkTransformFEMMesh.Update()
TransformedFEMMesh = vtkTransformFEMMesh.GetOutput()
# reflect
#vtkReflectX = vtk.vtkReflectionFilter()
#vtkReflectX.SetPlaneToXMin()
#vtkReflectX.SetInput( TransformedFEMMesh )
#vtkReflectX.Update()
# reflect
#vtkReflectZ = vtk.vtkReflectionFilter()
#vtkReflectZ.SetPlaneToZMax()
#vtkReflectZ.SetInput( vtkReflectX.GetOutput() )
#vtkReflectZ.Update()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( templateImage )
vtkResample.SetSource( TransformedFEMMesh )
#vtkResample.SetSource( vtkReflectZ.GetOutput() )
vtkResample.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
u0_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0'))
u0star_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0*'))
u1_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u1'))
#go from 1x256^2 array to 256X256 array for each timestep
for nn in range(0,matsize):
u0_array_1[nn,:]=u0_array[nn*matsize:(nn+1)*matsize]
u0star_array_1[nn,:]=u0star_array[nn*matsize:(nn+1)*matsize]
u1_array_1[nn,:]=u1_array[nn*matsize:(nn+1)*matsize]
#apply proper rotations/reflections and combine 2D arrays into 3D array
u0_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u0_array_1,k=3))
u0star_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u0star_array_1,k=3))
u1_array_2[:,:,timeID-1]=numpy.fliplr(numpy.rot90(u1_array_1,k=3))
# write numpy to disk in matlab
#scipyio.savemat("MS795.%04d.mat" % (timeID), {'u0':u1_array,'MRTI0':MRTI0_array })
# write output
print "writing ", timeID
vtkStatsWriter = vtk.vtkDataSetWriter()
vtkStatsWriter.SetFileTypeToBinary()
vtkStatsWriter.SetFileName("test.%04d.vtk" % timeID )
vtkStatsWriter.SetInput(vtkResample.GetOutput())
vtkStatsWriter.Update()
scipyio.savemat("S695.mat",{'ModelFluence':u1_array_2,'MRTI':u0star_array_2,'ModelTemp':u0_array_2})
Vertices.InsertNextCell(1)
Vertices.InsertCellPoint(pointID)
Polydata.SetPoints(Points)
Polydata.SetVerts(Vertices)
Polydata.Modified()
if vtk.VTK_MAJOR_VERSION <= 5: Polydata.Update()
# ------------------------------------------ output result ---------------------------------------
if name:
writer = vtk.vtkXMLPolyDataWriter()
writer.SetCompressorTypeToZLib()
writer.SetDataModeToBinary()
writer.SetFileName(os.path.join(os.path.split(name)[0],
os.path.splitext(os.path.split(name)[1])[0] +
'.' + writer.GetDefaultFileExtension()))
else:
writer = vtk.vtkDataSetWriter()
writer.SetHeader('# powered by '+scriptID)
writer.WriteToOutputStringOn()
if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(Polydata)
else: writer.SetInputData(Polydata)
writer.Write()
if name is None: sys.stdout.write(writer.GetOutputString()[:writer.GetOutputStringLength()]) # limiting of outputString is fix for vtk <7.0
table.close()
def ComputeObjective(SEMDataDirectory,MRTIDirectory):
import vtk
import vtk.util.numpy_support as vtkNumPy
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
ObjectiveFunction = 0.0
# loop over time points of interest
for (SEMtimeID,MRTItimeID) in [(1,58)]:
# read SEM data
vtkSEMReader = vtk.vtkXMLUnstructuredGridReader()
vtufileName = "%s/%d.vtu" % (SEMDataDirectory,SEMtimeID)
vtkSEMReader.SetFileName( vtufileName )
vtkSEMReader.SetPointArrayStatus("Temperature",1)
vtkSEMReader.Update()
# get registration parameters
variableDictionary = kwargs['cv']
# register the SEM data to MRTI
AffineTransform = vtk.vtkTransform()
AffineTransform.Translate([
variableDictionary['x_displace'],variableDictionary['y_displace'],variableDictionary['z_displace']
])
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform.RotateZ(variableDictionary['z_rotate' ] )
AffineTransform.RotateY(variableDictionary['y_rotate' ] )
AffineTransform.RotateX(variableDictionary['x_rotate' ] )
AffineTransform.Scale([1.e3,1.e3,1.e3])
SEMRegister = vtk.vtkTransformFilter()
SEMRegister.SetInput(vtkSEMReader.GetOutput())
SEMRegister.SetTransform(AffineTransform)
SEMRegister.Update()
# write output
DebugObjective = True
if ( DebugObjective ):
vtkSEMWriter = vtk.vtkDataSetWriter()
vtkSEMWriter.SetFileTypeToBinary()
semfileName = "%s/semtransform%04d.vtk" % (SEMDataDirectory,SEMtimeID)
print "writing ", semfileName
vtkSEMWriter.SetFileName( semfileName )
vtkSEMWriter.SetInput(SEMRegister.GetOutput())
vtkSEMWriter.Update()
# load image
vtkImageReader = vtk.vtkDataSetReader()
vtkImageReader.SetFileName('%s/temperature.%04d.vtk' % (MRTIDirectory, MRTItimeID) )
vtkImageReader.Update()
## image_cells = vtkImageReader.GetOutput().GetPointData()
## data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
# extract voi for QOI
vtkVOIExtract = vtk.vtkExtractVOI()
vtkVOIExtract.SetInput( vtkImageReader.GetOutput() )
VOI = [110,170,70,120,0,0]
vtkVOIExtract.SetVOI( VOI )
vtkVOIExtract.Update()
mrti_point_data= vtkVOIExtract.GetOutput().GetPointData()
mrti_array = vtkNumPy.vtk_to_numpy(mrti_point_data.GetArray('image_data'))
#print mrti_array
#print type(mrti_array)
# project SEM onto MRTI for comparison
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetSource( SEMRegister.GetOutput() )
vtkResample.SetInput( vtkVOIExtract.GetOutput() )
vtkResample.Update()
# write output
if ( DebugObjective ):
vtkTemperatureWriter = vtk.vtkDataSetWriter()
vtkTemperatureWriter.SetFileTypeToBinary()
roifileName = "%s/roi%04d.vtk" % (SEMDataDirectory,SEMtimeID)
print "writing ", roifileName
vtkTemperatureWriter.SetFileName( roifileName )
vtkTemperatureWriter.SetInput(vtkResample.GetOutput())
vtkTemperatureWriter.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
fem_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('Temperature'))
#print fem_array
#print type(fem_array )
# accumulate objective function
diff = mrti_array-fem_array
diffsq = diff**2
ObjectiveFunction = ObjectiveFunction + diffsq.sum()
return ObjectiveFunction
ren1.GetActiveCamera().SetClippingRange(79.2526, 194.052)
iren.Initialize()
renWin.Render()
# render the image
#
# prevent the tk window from showing up then start the event loop
#
# If the current directory is writable, then test the witers
#
if (catch.catch(globals(), """channel = open("test.tmp", "w")""") == 0):
channel.close()
file.delete("-force", "test.tmp")
#
#
# test the writers
dsw = vtk.vtkDataSetWriter()
dsw.SetInputConnection(smooth.GetOutputPort())
dsw.SetFileName("brain.dsw")
dsw.Write()
file.delete("-force", "brain.dsw")
pdw = vtk.vtkPolyDataWriter()
pdw.SetInputConnection(smooth.GetOutputPort())
pdw.SetFileName("brain.pdw")
pdw.Write()
file.delete("-force", "brain.pdw")
if (info.command(globals(), locals(), "vtkIVWriter") != ""):
iv = vtk.vtkIVWriter()
iv.SetInputConnection(smooth.GetOutputPort())
iv.SetFileName("brain.iv")
iv.Write()
file.delete("-force", "brain.iv")
def deltapModeling(**kwargs):
"""
treatment planning model
"""
# import petsc and numpy
import petsc4py, numpy
# init petsc
PetscOptions = sys.argv
PetscOptions.append("-ksp_monitor")
PetscOptions.append("-ksp_rtol")
PetscOptions.append("1.0e-15")
#PetscOptions.append("-help")
#PetscOptions.append("-idb")
petsc4py.init(PetscOptions)
#
# break processors into separate communicators
from petsc4py import PETSc
petscRank = PETSc.COMM_WORLD.getRank()
petscSize = PETSc.COMM_WORLD.Get_size()
sys.stdout.write("petsc rank %d petsc nproc %d\n" % (petscRank, petscSize))
# set shell context
# TODO import vtk should be called after femLibrary ????
# FIXME WHY IS THIS????
import femLibrary
# initialize libMesh data structures
libMeshInit = femLibrary.PyLibMeshInit(PetscOptions,PETSc.COMM_WORLD)
# store control variables
getpot = femLibrary.PylibMeshGetPot(PetscOptions)
# from Duck table 2.15
getpot.SetIniValue( "material/specific_heat","3840.0" )
# set ambient temperature
getpot.SetIniValue( "initial_condition/u_init","0.0" )
# from Duck
getpot.SetIniValue( "thermal_conductivity/k_0_healthy",kwargs['cv']['k_0_healthy'] )
getpot.SetIniValue( "thermal_conductivity/k_0_tumor",kwargs['cv']['k_0_healthy'] )
# water properties at http://www.d-a-instruments.com/light_absorption.html
getpot.SetIniValue( "optical/mu_a_healthy", kwargs['cv']['mu_a_healthy'] )
# FIXME large mu_s (> 30) in agar causing negative fluence to satisfy BC
getpot.SetIniValue( "optical/mu_s_healthy",
kwargs['cv']['mu_s_healthy'] )
# from AE paper
#http://scitation.aip.org/journals/doc/MPHYA6-ft/vol_36/iss_4/1351_1.html#F3
#For SPIOs
#getpot.SetIniValue( "optical/guass_radius","0.0035" )
#For NR/NS
getpot.SetIniValue( "optical/guass_radius",".0025" )
# 1-300
getpot.SetIniValue( "optical/mu_a_tumor",
kwargs['cv']['mu_a_tumor'] )
# 1-300
getpot.SetIniValue( "optical/mu_s_tumor",
kwargs['cv']['mu_s_tumor'] )
#getpot.SetIniValue( "optical/mu_a_tumor","71.0" )
#getpot.SetIniValue( "optical/mu_s_tumor","89.0" )
# .9 - .99
getpot.SetIniValue( "optical/anfact",kwargs['cv']['anfact'] )
#agar length
#for SPIOs
#getpot.SetIniValue( "optical/agar_length","0.0206" )
#for NR/NS
getpot.SetIniValue( "optical/agar_length","0.023" )
getpot.SetIniValue("optical/refractive_index","1.0")
#
# given the original orientation as two points along the centerline z = x2 -x1
# the transformed orienteation would be \hat{z} = A x2 + b - A x1 - b = A z
# ie transformation w/o translation which is exactly w/ vtk has implemented w/ TransformVector
# TransformVector = TransformPoint - the transation
#Setup Affine Transformation for registration
RotationMatrix = [[1.,0.,0.],
[0.,1.,0.],
[0.,0.,1.]]
Translation = [0.,0.,0.]
# original coordinate system laser input
# For SPIOs 67_11
#laserTip = [0.,-.000625,.035]
# For SPIOs 67_10
#laserTip = [0.,-.0001562,.035]
# For SPIOs 335_11
#laserTip = [0.,-.0014062,.035]
# For NR
#laserTip = [0.,.0002,.035]
# For NS
laserTip = [0.,.001,.035]
laserOrientation = [0.,0.,-1.0 ]
import vtk
import vtk.util.numpy_support as vtkNumPy
# echo vtk version info
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
# FIXME notice that order of operations is IMPORTANT
# FIXME translation followed by rotation will give different results
# FIXME than rotation followed by translation
# FIXME Translate -> RotateZ -> RotateY -> RotateX -> Scale seems to be the order of paraview
AffineTransform = vtk.vtkTransform()
# should be in meters
# For 67_11
#AffineTransform.Translate([ kwargs['cv']['x_translate'],
# 0.0375,0.0033])
#AffineTransform.RotateZ( 0.0 )
#AffineTransform.RotateY(-90.0 )
#AffineTransform.RotateX( 2.0 )
# For 67_10
#AffineTransform.Translate([ kwargs['cv']['x_translate'],
# 0.03025,0.0033])
#AffineTransform.RotateZ( 0.0 )
#AffineTransform.RotateY(-90.0 )
#AffineTransform.RotateX( 1.0 )
#AffineTransform.Scale([1.,1.,1.])
# For 335_11
#AffineTransform.Translate([ kwargs['cv']['x_translate'],
# 0.0333,0.0033])
#AffineTransform.RotateZ( 0.0 )
#AffineTransform.RotateY(-90.0 )
#AffineTransform.RotateX( 3.0 )
#AffineTransform.Scale([1.,1.,1.])
# For NR
#AffineTransform.Translate([ kwargs['cv']['x_translate'],
# 0.00570,-0.0001])
#AffineTransform.RotateZ( 0.0 )
#AffineTransform.RotateY(-90.0 )
#AffineTransform.RotateX( 2.0 )
#AffineTransform.Scale([1.,1.,1.])
# For NS
AffineTransform.Translate([ kwargs['cv']['x_translate'],
0.00675,-0.0001])
AffineTransform.RotateZ( 0.0 )
AffineTransform.RotateY(-90.0 )
AffineTransform.RotateX( 0.0 )
AffineTransform.Scale([1.,1.,1.])
# get homogenius 4x4 matrix of the form
# A | b
# matrix = -----
# 0 | 1
#
matrix = AffineTransform.GetConcatenatedTransform(0).GetMatrix()
#print matrix
RotationMatrix = [[matrix.GetElement(0,0),matrix.GetElement(0,1),matrix.GetElement(0,2)],
[matrix.GetElement(1,0),matrix.GetElement(1,1),matrix.GetElement(1,2)],
[matrix.GetElement(2,0),matrix.GetElement(2,1),matrix.GetElement(2,2)]]
Translation = [matrix.GetElement(0,3),matrix.GetElement(1,3),matrix.GetElement(2,3)]
#print RotationMatrix ,Translation
laserTip = AffineTransform.TransformPoint( laserTip )
laserOrientation = AffineTransform.TransformVector( laserOrientation )
# set laser orientation values
getpot.SetIniValue( "probe/x_0","%f" % laserTip[0])
getpot.SetIniValue( "probe/y_0","%f" % laserTip[1])
getpot.SetIniValue( "probe/z_0","%f" % laserTip[2])
getpot.SetIniValue( "probe/x_orientation","%f" % laserOrientation[0] )
getpot.SetIniValue( "probe/y_orientation","%f" % laserOrientation[1] )
getpot.SetIniValue( "probe/z_orientation","%f" % laserOrientation[2] )
# initialize FEM Mesh
femMesh = femLibrary.PylibMeshMesh()
# must setup Ini File first
#For SPIOs
#femMesh.SetupUnStructuredGrid( "/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/phantomMeshFullTess.e",0,RotationMatrix, Translation )
#For NS/NR
meshFile = "../phantomMeshFull.e"
meshFile = "../phantomMesh.e"
femMesh.SetupUnStructuredGrid( meshFile ,0,RotationMatrix, Translation )
#femMesh.SetupUnStructuredGrid( "phantomMesh.e",0,RotationMatrix, Translation )
MeshOutputFile = "fem_data.%04d.e" % kwargs['fileID']
#femMes.SetupStructuredGrid( (10,10,4) ,[0.0,1.0],[0.0,2.0],[0.0,1.0])
# add the data structures for the background system solve
# set deltat, number of time steps, power profile, and add system
nsubstep = 1
#for SPIOs
#acquisitionTime = 4.9305
#for NS/NR
acquisitionTime = 5.053
deltat = acquisitionTime / nsubstep
ntime = 60
eqnSystems = femLibrary.PylibMeshEquationSystems(femMesh,getpot)
#For SPIOs
#getpot.SetIniPower(nsubstep, [ [1,6,30,ntime],[1.0,0.0,4.5,0.0] ])
#For NS/NR
getpot.SetIniPower(nsubstep, [ [1,6,42,ntime],[1.0,0.0,1.0,0.0] ])
deltapSystem = eqnSystems.AddPennesDeltaPSystem("StateSystem",deltat)
deltapSystem.AddStorageVectors(ntime)
# hold imaging
mrtiSystem = eqnSystems.AddExplicitSystem( "MRTI" )
mrtiSystem.AddFirstLagrangeVariable( "u0*" )
mrtiSystem.AddStorageVectors(ntime)
maskSystem = eqnSystems.AddExplicitSystem( "ImageMask" )
maskSystem.AddFirstLagrangeVariable( "mask" )
# initialize libMesh data structures
eqnSystems.init( )
# print info
eqnSystems.PrintSelf()
# read imaging data geometry that will be used to project FEM data onto
#For 67_11
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/67_11/tmap_67_11.0000.vtk')
#For 67_10
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/67_10/tmap_67_10.0000.vtk')
#For 335_11
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/spio/spioVTK/335_11/tmap_335_11.0000.vtk')
#For NS
#vtkReader.SetFileName('/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/nrtmapsVTK/S695/S695.0000.vtk')
#For NR
#imageFileNameTemplate = '/work/01741/cmaclell/data/mdacc/deltap_phantom_oct10/nrtmapsVTK/S695/S695.%04d.vtk'
#imageFileNameTemplate = "/share/work/fuentes/deltap_phantom_oct10/nrtmapsVTK/R695/R695.%04d.vtk"
imageFileNameTemplate = "../nrtmapsVTK/R695/R695.%04d.vtk"
# get initial imaging data
nzero = kwargs['cv']['nzero']
#vtkReader = vtk.vtkXMLImageDataReader()
vtkReader = vtk.vtkDataSetReader()
vtkReader.SetFileName( imageFileNameTemplate % nzero )
vtkReader.Update()
templateImage = vtkReader.GetOutput()
dimensions = templateImage.GetDimensions()
spacing = templateImage.GetSpacing()
origin = templateImage.GetOrigin()
print spacing, origin, dimensions
# setup imaging
femImaging = femLibrary.PytttkImaging(getpot, dimensions ,origin,spacing)
# project onto fem
imageCells = vtkReader.GetOutput().GetPointData()
dataArray = vtkNumPy.vtk_to_numpy(imageCells.GetArray('scalars'))
v1 = PETSc.Vec().createWithArray(dataArray, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("MRTI",0.0,v1,eqnSystems)
mrtiSystem.StoreSystemTimeStep(nzero )
# check if we want to project imaging onto FEM as the IC
if (nzero != 0):
mrtidata = mrtiSystem.GetSolutionVector()
# write soln to disk for processing
eqnSystems.SetPetscFEMSystemSolnSubVector( "StateSystem",mrtidata,0)
eqnSystems.UpdatePetscFEMSystemTimeStep("StateSystem",nzero)
# write IC
exodusII_IO = femLibrary.PylibMeshExodusII_IO(femMesh)
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, 1, 0.0 )
# loop over time steps and solve
ObjectiveFunction = 0.0
for timeID in range(nzero+1,ntime*nsubstep):
#for timeID in range(1,10):
# project imaging onto fem mesh
vtkImageReader = vtk.vtkDataSetReader()
vtkImageReader.SetFileName( imageFileNameTemplate % timeID )
vtkImageReader.Update()
image_cells = vtkImageReader.GetOutput().GetPointData()
data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
v1 = PETSc.Vec().createWithArray(data_array, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("MRTI",0.0,v1,eqnSystems)
mrtiSystem.StoreSystemTimeStep(timeID )
# create image mask
# The = operator for numpy arrays just copies by reference
# .copy() provides a deep copy (ie physical memory copy)
image_mask = data_array.copy().reshape(dimensions,order='F')
# Set all image pixels to large value
largeValue = 1.e6
image_mask[:,:] = largeValue
# RMS error will be computed within this ROI/VOI imagemask[xcoords/column,ycoords/row]
#image_mask[93:153,52:112] = 1.0
image_mask[98:158,46:106] = 1.0
v2 = PETSc.Vec().createWithArray(image_mask, comm=PETSc.COMM_SELF)
femImaging.ProjectImagingToFEMMesh("ImageMask",largeValue,v2,eqnSystems)
#print mrti_array
#print type(mrti_array)
print "time step = " ,timeID
eqnSystems.UpdatePetscFEMSystemTimeStep("StateSystem",timeID )
deltapSystem.SystemSolve()
#eqnSystems.StoreTransientSystemTimeStep("StateSystem",timeID )
# accumulate objective function
#
# qoi = ( (FEM - MRTI) / ImageMask)^2
#
qoi = femLibrary.WeightedL2Norm( deltapSystem,"u0",
mrtiSystem,"u0*",
maskSystem,"mask" )
ObjectiveFunction =( ObjectiveFunction + qoi)
# control write output
writeControl = False
if ( timeID%nsubstep == 0 and writeControl ):
# write exodus file
exodusII_IO.WriteTimeStep(MeshOutputFile,eqnSystems, timeID+1, timeID*deltat )
# Interpolate FEM onto imaging data structures
if (vtk != None):
vtkExodusIIReader = vtk.vtkExodusIIReader()
vtkExodusIIReader.SetFileName(MeshOutputFile )
vtkExodusIIReader.SetPointResultArrayStatus("u0",1)
vtkExodusIIReader.SetTimeStep(timeID-1)
vtkExodusIIReader.Update()
# reflect
vtkReflect = vtk.vtkReflectionFilter()
vtkReflect.SetPlaneToYMax()
vtkReflect.SetInput( vtkExodusIIReader.GetOutput() )
vtkReflect.Update()
# reuse ShiftScale Geometry
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput( vtkImageReader.GetOutput() )
vtkResample.SetSource( vtkReflect.GetOutput() )
vtkResample.Update()
fem_point_data= vtkResample.GetOutput().GetPointData()
fem_array = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('u0'))
#print fem_array
#print type(fem_array )
# only rank 0 should write
if ( petscRank == 0 ):
print "writing ", timeID
vtkTemperatureWriter = vtk.vtkDataSetWriter()
vtkTemperatureWriter.SetFileTypeToBinary()
vtkTemperatureWriter.SetFileName("invspio_67_11.%04d.vtk" % timeID )
vtkTemperatureWriter.SetInput(vtkResample.GetOutput())
vtkTemperatureWriter.Update()
print 'Objective Fn'
print ObjectiveFunction
retval = dict([])
retval['fns'] = [ObjectiveFunction *10000000.]
retval['rank'] = petscRank
return(retval)
# setup command line parser to control execution
from optparse import OptionParser
parser = OptionParser()
parser.add_option( "--file_name",
action="store", dest="file_name", default=None,
help="converting/this/file.stl to converting/this/file.vtk", metavar = "FILE")
(options, args) = parser.parse_args()
if (options.file_name):
OutputFileName = options.file_name.split('.').pop(0) + '.vtk'
stlHelper = STLImageHelper(options.file_name)
vtkImage = stlHelper.ConvertNumpyVTKImage(stlHelper.ImageFile)
##print "resampling"
##vtkResample = vtk.vtkCompositeDataProbeFilter()
##vtkResample.SetSource( stlHelper.stlData )
##vtkResample.SetInput( vtkImage )
##vtkResample.Update()
##print vtkResample.GetOutput()
vtkImageDataWriter = vtk.vtkDataSetWriter()
vtkImageDataWriter.SetFileTypeToBinary()
print "writing ", OutputFileName
vtkImageDataWriter.SetFileName( OutputFileName )
##vtkImageDataWriter.SetInput(vtkResample.GetOutput())
vtkImageDataWriter.SetInput(vtkImage )
vtkImageDataWriter.Update()
else:
parser.print_help()
print options
def ConvertGadgetronVTK(input_filename, output_filename):
"""
http://sourceforge.net/p/gadgetron/home/Simple%20Array%20File%20Format/
When working with the Gadgetron it is often necessary to write files with
reconstructed images to disk, either as part of debugging or as the final
reconstruction result. We have adopted a very simple multidimensional array
file format for this purpose. The main advantage of this file format is its
simplicity but there are a number of disadvantages and caveats as well as
described in this section.
The simple array files are made up of a) a header followed by b) the data
itself. This layout of data and header is illustrated below. The header has a
single 32-bit integer to indicate the number of dimensions of the dataset
followed by one integer for each dimension to indicate the length of that
dimension. The data follows immediately after the header. The data is stored
such that the first dimension is the fastest moving dimension, second dimension
is second fastest, etc. The header contains no information about the size of
each individual data element and consequently the user needs to know what type
of data is contained in the array. In general, the Gadgetron uses 3 different
types of data and the convention is to use the file extension to indicate the
data type in the file:
16-bit unsigned short. File extension: *.short
32-bit float. File extension: *.real
32-bit complex float. Two 32-bit floating point values per data element. File extension: *.cplx
The Gadgetron framework provides function for reading these files in C++. The
functions are located in toolboxes/ndarray/hoNDArray_fileio.h in the Gadgetron
source code distribution.
It is also trivial to read the files into Matlab. Below is a function which
detects the data type based on the file extension and reads the file into
Matlab.
"""
import vtk.util.numpy_support as vtkNumPy
import numpy
import scipy.io as scipyio
# read the header
imagedimension = numpy.fromfile(input_filename,
dtype=numpy.int32,
count=1,
sep='')[0]
fileheader = numpy.fromfile(input_filename,
dtype=numpy.int32,
count=1 + imagedimension,
sep='')
print imagedimension, fileheader
if (imagedimension == 1):
dims = [fileheader[1], 1, 1, 1]
elif (imagedimension == 2):
dims = [fileheader[1], fileheader[2], 1, 1]
elif (imagedimension == 3):
dims = [fileheader[1], fileheader[2], fileheader[3], 1]
else:
raise RuntimeError('unknown dimension %d ' % imagedimension)
# the extension is the datatype
extension = input_filename.split('.').pop()
dataImporter = vtk.vtkImageImport()
WriteImageData = True
if extension == 'short':
datatype = numpy.short
dataImporter.SetDataScalarTypeToShort()
elif extension == 'real':
datatype = numpy.float32
dataImporter.SetDataScalarTypeToFloat()
elif extension == 'cplx':
datatype = numpy.float32
dataImporter.SetDataScalarTypeToFloat()
dims[3] = 2
WriteImageData = False
else:
raise RuntimeError('unknown data type %s ' % extension)
# offset the data read by the header
datafile = open(input_filename, "rb") # reopen the file
headeroffset = len(fileheader) * 4 # 4 bytes per integer
datafile.seek(headeroffset, os.SEEK_SET) # seek
numpy_data = numpy.fromfile(datafile, dtype=datatype, sep='')
# error check
ExpectedImageSize = 1
for pixelsize in dims:
ExpectedImageSize = ExpectedImageSize * pixelsize
if (ExpectedImageSize != numpy_data.size):
raise RuntimeError(
'file read error: expected size %d, size found %d ' %
(ExpectedImageSize, numpy_data.size))
# FIXME Hack for trajectory Points
if (WriteImageData):
# convert to vtk
spacing = [1., 1., 1.]
dataImporter.SetNumberOfScalarComponents(dims[3])
dataImporter.SetDataExtent(0, dims[0] - 1, 0, dims[1] - 1, 0,
dims[2] - 1)
dataImporter.SetWholeExtent(0, dims[0] - 1, 0, dims[1] - 1, 0,
dims[2] - 1)
dataImporter.SetDataSpacing(spacing[0], spacing[1], spacing[2])
#numpy_data= numpy_data.reshape(dims[0],dims[1],dims[2])
#numpy_data= numpy_data.transpose(1,0,2)
data_string = numpy_data.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetScalarArrayName(input_filename.split('.').pop(0))
# write vtk file
print "writing ", output_filename
vtkImageDataWriter = vtk.vtkDataSetWriter()
vtkImageDataWriter.SetFileTypeToBinary()
vtkImageDataWriter.SetFileName(output_filename)
vtkImageDataWriter.SetInput(dataImporter.GetOutput())
vtkImageDataWriter.Update()
else:
#TODO need to correct spacing
WriteVTKPoints(numpy_data.reshape(dims[0], dims[3]), output_filename)
def ConvertGadgetronVTK(input_filename, output_filename):
"""
http://sourceforge.net/p/gadgetron/home/Simple%20Array%20File%20Format/
When working with the Gadgetron it is often necessary to write files with
reconstructed images to disk, either as part of debugging or as the final
reconstruction result. We have adopted a very simple multidimensional array
file format for this purpose. The main advantage of this file format is its
simplicity but there are a number of disadvantages and caveats as well as
described in this section.
The simple array files are made up of a) a header followed by b) the data
itself. This layout of data and header is illustrated below. The header has a
single 32-bit integer to indicate the number of dimensions of the dataset
followed by one integer for each dimension to indicate the length of that
dimension. The data follows immediately after the header. The data is stored
such that the first dimension is the fastest moving dimension, second dimension
is second fastest, etc. The header contains no information about the size of
each individual data element and consequently the user needs to know what type
of data is contained in the array. In general, the Gadgetron uses 3 different
types of data and the convention is to use the file extension to indicate the
data type in the file:
16-bit unsigned short. File extension: *.short
32-bit float. File extension: *.real
32-bit complex float. Two 32-bit floating point values per data element. File extension: *.cplx
The Gadgetron framework provides function for reading these files in C++. The
functions are located in toolboxes/ndarray/hoNDArray_fileio.h in the Gadgetron
source code distribution.
It is also trivial to read the files into Matlab. Below is a function which
detects the data type based on the file extension and reads the file into
Matlab.
"""
import vtk.util.numpy_support as vtkNumPy
import numpy
import scipy.io as scipyio
# read the header
imagedimension = numpy.fromfile(input_filename, dtype=numpy.int32, count=1, sep="")[0]
fileheader = numpy.fromfile(input_filename, dtype=numpy.int32, count=1 + imagedimension, sep="")
print imagedimension, fileheader
if imagedimension == 1:
dims = [fileheader[1], 1, 1, 1]
elif imagedimension == 2:
dims = [fileheader[1], fileheader[2], 1, 1]
elif imagedimension == 3:
dims = [fileheader[1], fileheader[2], fileheader[3], 1]
else:
raise RuntimeError("unknown dimension %d " % imagedimension)
# the extension is the datatype
extension = input_filename.split(".").pop()
dataImporter = vtk.vtkImageImport()
WriteImageData = True
if extension == "short":
datatype = numpy.short
dataImporter.SetDataScalarTypeToShort()
elif extension == "real":
datatype = numpy.float32
dataImporter.SetDataScalarTypeToFloat()
elif extension == "cplx":
datatype = numpy.float32
dataImporter.SetDataScalarTypeToFloat()
dims[3] = 2
WriteImageData = False
else:
raise RuntimeError("unknown data type %s " % extension)
# offset the data read by the header
datafile = open(input_filename, "rb") # reopen the file
headeroffset = len(fileheader) * 4 # 4 bytes per integer
datafile.seek(headeroffset, os.SEEK_SET) # seek
numpy_data = numpy.fromfile(datafile, dtype=datatype, sep="")
# error check
ExpectedImageSize = 1
for pixelsize in dims:
ExpectedImageSize = ExpectedImageSize * pixelsize
if ExpectedImageSize != numpy_data.size:
raise RuntimeError("file read error: expected size %d, size found %d " % (ExpectedImageSize, numpy_data.size))
# FIXME Hack for trajectory Points
if WriteImageData:
# convert to vtk
spacing = [1.0, 1.0, 1.0]
dataImporter.SetNumberOfScalarComponents(dims[3])
dataImporter.SetDataExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
dataImporter.SetWholeExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
dataImporter.SetDataSpacing(spacing[0], spacing[1], spacing[2])
# numpy_data= numpy_data.reshape(dims[0],dims[1],dims[2])
# numpy_data= numpy_data.transpose(1,0,2)
data_string = numpy_data.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetScalarArrayName(input_filename.split(".").pop(0))
# write vtk file
print "writing ", output_filename
vtkImageDataWriter = vtk.vtkDataSetWriter()
vtkImageDataWriter.SetFileTypeToBinary()
vtkImageDataWriter.SetFileName(output_filename)
vtkImageDataWriter.SetInput(dataImporter.GetOutput())
vtkImageDataWriter.Update()
else:
# TODO need to correct spacing
WriteVTKPoints(numpy_data.reshape(dims[0], dims[3]), output_filename)
rGrid.SetZCoordinates(coordArray[2])
# ------------------------------------------ output result ---------------------------------------
if name:
writer = vtk.vtkXMLRectilinearGridWriter()
writer.SetCompressorTypeToZLib()
writer.SetDataModeToBinary()
writer.SetFileName(
os.path.join(
os.path.split(name)[0],
os.path.splitext(os.path.split(name)[1])[0] +
'_{}({})'.format(options.pos, options.mode) + '.' +
writer.GetDefaultFileExtension()))
else:
writer = vtk.vtkDataSetWriter()
writer.SetHeader('# powered by ' + scriptID)
writer.WriteToOutputStringOn()
if vtk.VTK_MAJOR_VERSION <= 5: writer.SetInput(rGrid)
else: writer.SetInputData(rGrid)
writer.Write()
if name is None:
sys.stdout.write(
writer.GetOutputString()[:writer.GetOutputStringLength(
)]) # limiting of outputString is fix for vtk <7.0
table.close()
def write(data,filename):
writer = vtk.vtkDataSetWriter()
writer.SetFileName(filename + ".vtk")
writer.SetInputData(data)
writer.Write()
print "Data written to file:\t " + filename +".vtk"
def writeDatasets(self, event = None):
"""
A method that writes the datasets
"""
dirname = self.browsedir.GetValue()
pattern = self.patternEdit.GetValue()
if self.imageMode == 0:
ext = "ome.tif"
writer = vtkbxd.vtkOMETIFFWriter()
elif self.imageMode == 2:
fext = self.vtkmenu.GetString(self.vtkmenu.GetSelection())
if fext.find("XML") != -1:
ext = "vti"
writer = vtk.vtkXMLImageDataWriter()
else:
ext = "vtk"
writer = vtk.vtkDataSetWriter()
else:
return
pattern = os.path.join(dirname,pattern) + "." + ext
self.dlg = wx.ProgressDialog("Writing", "Writing dataset %d / %d" % (0, 0), maximum = self.imageAmnt, parent = self, style = wx.PD_ELAPSED_TIME | wx.PD_REMAINING_TIME | wx.PD_AUTO_HIDE)
filenames = self.sourceListbox.GetItems()
if len(filenames) != self.c * self.t:
return
if self.imageMode == 0: # vtkOMETIFFWriter specific
writer.SetFileNamePattern(pattern)
writer.SetTimePoints(self.t)
writer.SetChannels(self.c)
# Create uuids
if self.imageAmnt > 1:
for i in range(self.imageAmnt):
uid = uuid.uuid4()
writer.SetUUID(i,uid.get_urn())
for c in range(self.c):
ch_name = self.dataUnits[c].getName()
excitation = int(self.dataUnits[c].getExcitationWavelength())
emission = int(self.dataUnits[c].getEmissionWavelength())
writer.SetChannelInfo(ch_name, excitation, emission)
i = 0
for c in range(self.c):
imageName = self.dataUnits[c].getImageName()
voxelSize = self.dataUnits[c].getVoxelSize()
if self.t > 1:
try:
timeInc = self.dataUnits[c].getTimeStamp(1) - self.dataUnits[c].getTimeStamp(0)
except:
timeInc = 0.0
for t in range(self.t):
filenm = filenames[i]
i += 1
self.dlg.Update(i, "Writing dataset %d / %d" % (i, self.imageAmnt))
if self.imageMode == 0:
writer.SetCurrentChannel(c)
writer.SetCurrentTimePoint(t)
writer.SetImageName(imageName)
writer.SetXResolution(voxelSize[0] * 10**6)
writer.SetYResolution(voxelSize[1] * 10**6)
writer.SetZResolution(voxelSize[2] * 10**6)
if self.t > 1:
writer.SetTimeIncrement(timeInc)
writer.SetFileName(filenm)
data = self.dataUnits[c].getTimepoint(t)
data.SetUpdateExtent(data.GetWholeExtent())
data.Update()
writer.SetInput(data)
writer.Write()
self.dlg.Destroy()
LandmarkTransform = vtk.vtkLandmarkTransform()
LandmarkTransform.SetSourceLandmarks(SourceLMReader.GetOutput().GetPoints())
LandmarkTransform.SetTargetLandmarks(TargetLMReader.GetOutput().GetPoints())
LandmarkTransform.SetModeToRigidBody()
LandmarkTransform.Update()
print LandmarkTransform.GetMatrix()
# apply transform
transformFilter = vtk.vtkTransformFilter()
#transformFilter.SetInput(vtkCylinder.GetOutput() )
transformFilter.SetInput(trianglefilter.GetOutput())
transformFilter.SetTransform(LandmarkTransform)
transformFilter.Update()
# write model
modelWriter = vtk.vtkDataSetWriter()
modelWriter.SetInput(transformFilter.GetOutput())
modelWriter.SetFileName("needle.vtk")
modelWriter.SetFileTypeToBinary()
modelWriter.Update()
# read image/ROI
ImageReader = vtk.vtkDataSetReader()
ImageReader.SetFileName("newimage.vtk")
ImageReader.Update()
# resample needle to image to create mask
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetInput(ImageReader.GetOutput())
vtkResample.SetSource(transformFilter.GetOutput())
vtkResample.Update()
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToDouble()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
print dimensions
dataImporter.SetDataExtent(0, dimensions[0] - 1, 0, dimensions[1] - 1,
0, dimensions[2] - 1)
dataImporter.SetWholeExtent(0, dimensions[0] - 1, 0, dimensions[1] - 1,
0, dimensions[2] - 1)
dataImporter.SetDataSpacing(spacing)
dataImporter.SetDataOrigin(origin)
# cast to float
vtkModelPrediction = vtk.vtkImageCast()
vtkModelPrediction.SetInput(dataImporter.GetOutput())
vtkModelPrediction.SetOutputScalarTypeToFloat()
vtkModelPrediction.Update()
# write output
print "writing ", timeID
vtkTemperatureWriter = vtk.vtkDataSetWriter()
vtkTemperatureWriter.SetFileTypeToBinary()
vtkTemperatureWriter.SetFileName("modeltemperature.%04d.vtk" % timeID)
vtkTemperatureWriter.SetInput(vtkModelPrediction.GetOutput())
vtkTemperatureWriter.Update()
def DataSetPrepare():
boxSTL=vtk.vtkSTLReader()
boxSTL.SetFileName(box)
boxSTL.Update()
boxbounds=boxSTL.GetOutput().GetBounds()
betonasSTL=vtk.vtkSTLReader()
betonasSTL.SetFileName(betonas)
betonasSTL.Update()
bounds=betonasSTL.GetOutput().GetBounds()
print(bounds)
reader=vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName("final.vtu")
reader.Update()
KIEKIS=reader.GetOutput().GetNumberOfPoints()
NumberOfCells=reader.GetOutput().GetNumberOfCells()
poly=vtk.vtkPolyData()
pp=vtk.vtkPoints();
pp.SetNumberOfPoints(KIEKIS)
rad_seg=vtk.vtkDoubleArray()
rad_seg.SetName("UNIQUE_RADIUS")
rad_seg.SetNumberOfComponents(1)
rad_seg.SetNumberOfTuples(1)
rad_seg.SetTuple1(0,RMIN)
rad=vtk.vtkDoubleArray()
rad.SetName("RADIUS")
rad.SetNumberOfComponents(1)
rad.SetNumberOfTuples(KIEKIS)
vel=vtk.vtkDoubleArray()
vel.SetName("VELOCITY")
vel.SetNumberOfComponents(3)
vel.SetNumberOfTuples(KIEKIS)
part_type=vtk.vtkIntArray()
part_type.SetName("PARTICLE_TYPE")
part_type.SetNumberOfComponents(1)
part_type.SetNumberOfTuples(KIEKIS)
part_material=vtk.vtkIntArray()
part_material.SetName("PARTICLE_MATERIAL")
part_material.SetNumberOfComponents(1)
part_material.SetNumberOfTuples(KIEKIS)
part_fix=vtk.vtkIntArray()
part_fix.SetName("PARTICLE_FIX")
part_fix.SetNumberOfComponents(1)
part_fix.SetNumberOfTuples(KIEKIS)
for x in range(KIEKIS):
r=reader.GetOutput().GetPointData().GetArray("RADIUS").GetTuple1(x)
pid=reader.GetOutput().GetPointData().GetArray("ID").GetTuple1(x)
p=reader.GetOutput().GetPoint(x)
pp.SetPoint(x,p)
rad.SetTuple1(x,r)
vel.SetTuple3(x,0,0,0)
part_type.SetTuple1(x,0)
part_fix.SetTuple1(x,0)
part_material.SetTuple1(x,pid)
if(False):
if(p[2]<bounds[4]):
vel.SetTuple3(x,0,0,0)
part_fix.SetTuple1(x,1)
if(p[2]>bounds[5]):
vel.SetTuple3(x,0,0,v)
part_fix.SetTuple1(x,1)
else:
if(p[1]<bounds[2]):
vel.SetTuple3(x,0,0,0)
part_fix.SetTuple1(x,1)
if(p[1]>bounds[3]):
vel.SetTuple3(x,0,v,0)
part_fix.SetTuple1(x,1)
cellsLines=vtk.vtkCellArray()
state=vtk.vtkIntArray()
state.SetName("STATE")
state.SetNumberOfComponents(1)
state.SetNumberOfTuples(NumberOfCells)
force_N=vtk.vtkDoubleArray()
force_N.SetName("F_N_LIMIT")
force_N.SetNumberOfComponents(1)
force_N.SetNumberOfTuples(NumberOfCells)
force_T=vtk.vtkDoubleArray()
force_T.SetName("F_T_LIMIT")
force_T.SetNumberOfComponents(1)
force_T.SetNumberOfTuples(NumberOfCells)
for x in range(NumberOfCells):
cell=reader.GetOutput().GetCell(x)
cellsLines.InsertNextCell(2);
cellsLines.InsertCellPoint(cell.GetPointId(0));
cellsLines.InsertCellPoint(cell.GetPointId(1));
state.SetTuple1(x,0)
bond_id=int(reader.GetOutput().GetCellData().GetArray("BONDS_ID").GetTuple1(x))
force_T.SetTuple1(x,0)
force_N.SetTuple1(x,random.uniform(F_N_RANGES[bond_id][0],F_N_RANGES[bond_id][1]))
force_T.SetTuple1(x,random.uniform(F_T_RANGES[bond_id][0],F_T_RANGES[bond_id][1]))
poly.SetPoints(pp)
poly.GetPointData().SetScalars(rad)
poly.GetPointData().AddArray(vel)
poly.GetPointData().AddArray(part_type)
poly.GetPointData().AddArray(part_fix)
poly.GetPointData().AddArray(part_material)
poly.GetFieldData().AddArray(rad_seg)
poly.SetLines(cellsLines)
poly.GetCellData().SetScalars(state)
poly.GetCellData().AddArray(force_N)
poly.GetCellData().AddArray(force_T)
#
writer=vtk.vtkXMLPolyDataWriter()
writer.SetFileName("input.vtp")
#writer.SetInputData(poly)
writer.SetInputData(poly)
writer.Write()
aa=vtk.vtkDataSetWriter()
aa.SetFileName("mesh.vtk")
aa.SetInputConnection(boxSTL.GetOutputPort())
aa.Write()
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
print dimensions
FEMdataImporter.SetDataExtent(0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1)
FEMdataImporter.SetWholeExtent(0, dimensions[0] - 1, 0, dimensions[1] - 1, 0, dimensions[2] - 1)
FEMdataImporter.SetDataSpacing(spacing)
FEMdataImporter.SetDataOrigin(origin)
# cast to float
vtkModelPrediction = vtk.vtkImageCast()
vtkModelPrediction.SetInput(FEMdataImporter.GetOutput())
vtkModelPrediction.SetOutputScalarTypeToFloat()
vtkModelPrediction.Update()
# write output
print "writing ", timeID
vtkTemperatureWriter = vtk.vtkDataSetWriter()
vtkTemperatureWriter.SetFileTypeToBinary()
vtkTemperatureWriter.SetFileName("modeltemperature.%04d.vtk" % timeID)
vtkTemperatureWriter.SetInput(vtkModelPrediction.GetOutput())
vtkTemperatureWriter.Update()
# save as matlab file
import scipy.io as sio
vect = numpy.arange(10)
print vect.shape
sio.savemat("vector.mat", {"vect": vect})
#
# generate tensors
ptLoad = vtk.vtkPointLoad()
ptLoad.SetLoadValue(100.0)
ptLoad.SetSampleDimensions(20, 20, 20)
ptLoad.ComputeEffectiveStressOn()
ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10)
#
# If the current directory is writable, then test the writers
#
try:
channel = open("wSP.vtk", "wb")
channel.close()
wSP = vtk.vtkDataSetWriter()
wSP.SetInputConnection(ptLoad.GetOutputPort())
wSP.SetFileName("wSP.vtk")
wSP.SetTensorsName("pointload")
wSP.SetScalarsName("effective_stress")
wSP.Write()
rSP = vtk.vtkDataSetReader()
rSP.SetFileName("wSP.vtk")
rSP.SetTensorsName("pointload")
rSP.SetScalarsName("effective_stress")
rSP.Update()
input = rSP.GetOutput()
# cleanup