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 _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 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})