def to_vtk(self, file_name):
for i, time in enumerate(self.times):
file_base, file_ext = os.path.splitext(file_name)
if file_ext == ".vtk":
writer = vtk.vtkStructuredGridWriter()
elif file_ext == ".vts":
writer = vtk.vtkXMLStructuredGridWriter()
elif file_ext == "":
file_name = file_base + ".vts"
writer = vtk.vtkXMLStructuredGridWriter()
else:
msg = "This function can only use the vtk or vts file extension not %s" % file_ext
raise ValueError(msg)
grid = self.CoordDF.vtkStructuredGrid()
if len(self.times) > 1:
num_zeros = int(np.log10(len(self.times))) + 1
ext = str(num_zeros).zfill(num_zeros)
file_name = os.path.join(file_name, ".%s" % ext)
for comp in self.comp:
grid.cell_arrays[np.str_(comp)] = self[time, comp].flatten()
# pyvista.save_meshio(file_name,grid,file_format="vtk")
writer.SetFileName(file_name)
if vtk.vtkVersion().GetVTKMajorVersion() <= 5:
grid.Update()
writer.SetInput(grid)
else:
writer.SetInputData(grid)
writer.Write()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkXMLStructuredGridWriter(), 'Writing vtkXMLStructuredGrid.',
('vtkXMLStructuredGrid',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def _save_structured_grid(filename, vtkStructGrid, directory=''):
"""Saves a VTK structured grid file (vtk) for an already generated
:class:`pyvista.StructuredGrid` object.
Parameters
----------
filename : str
path to the output vtk file or just its name if directory is specified
directory : str
directory where the UBC GIF file lives
"""
if not isinstance(vtkStructGrid, vtk.vtkStructuredGrid):
raise RuntimeError(
'`_save_structured_grid` can only handle `vtkStructuredGrid` objects. `{}` is not supported.'
.format(vtkStructGrid.__class__))
# Check the extension of the filename
fname = os.path.join(directory, filename)
ext = os.path.splitext(fname)[1]
if ext is '':
fname = fname + '.vts'
elif ext not in '.vts':
raise IOError(
'{:s} is an incorrect extension, has to be .vts'.format(ext))
# Make the writer
writer = vtkXMLStructuredGridWriter()
if float(VTK_VERSION.split('.')[0]) >= 6:
writer.SetInputDataObject(vtkStructGrid)
else:
writer.SetInput(vtkStructGrid)
writer.SetFileName(fname)
# Write the file
writer.Update()
def export2vts(self, filename):
import vtk
grid = self.info['grid']
# Set grid points
points = vtk.vtkPoints()
for z in range (grid[2]):
for y in range (grid[1]):
for x in range (grid[0]):
points.InsertNextPoint( [x , y , z ] )
struGrid = vtk.vtkStructuredGrid()
struGrid.SetDimensions( grid )
struGrid.SetPoints( points )
struGrid.Update()
# Set point data
grid_pt_num = struGrid.GetNumberOfPoints()
array = vtk.vtkIntArray()
array.SetNumberOfComponents(1) # this is 3 for a vector
array.SetNumberOfTuples(grid_pt_num)
array.SetName('MicrostructureID')
matPoint = self.microstructure.reshape( [grid_pt_num] )
for i in range(grid_pt_num):
array.SetValue(i, matPoint[i])
struGrid.GetPointData().AddArray(array)
struGrid.Update()
# Write output file
outWriter = vtk.vtkXMLStructuredGridWriter()
outWriter.SetDataModeToBinary()
outWriter.SetCompressorTypeToZLib()
outWriter.SetFileName( filename + '.vts' )
outWriter.SetInput(struGrid)
outWriter.Update()
outWriter.Write()
def write_3d_scalar_fields_as_vtk_point_data(dat, result_filename, scale_factor=1.0): vtk_p = vtk.vtkPoints() x_vec,y_vec,z_vec = [np.array(x)*scale_factor for x in dat["grid_points"]] fields_dat = dat["fields"] xlen = len(x_vec) ylen = len(y_vec) zlen = len(z_vec) vtk_fields = [] for fi in fields_dat: vfi = vtk.vtkDoubleArray() vfi.SetName(fi["name"]) vtk_fields.append(vfi) n_fields = len(vtk_fields) for zi in range(zlen): for yi in range(ylen): for xi in range(xlen): vtk_p.InsertNextPoint([x_vec[xi],y_vec[yi],z_vec[zi]]) for i in range(n_fields): vtk_fields[i].InsertNextValue(fields_dat[i]["data"][xi, yi, zi]) vtk_grid = vtk.vtkStructuredGrid() vtk_grid.SetDimensions(xlen,ylen,zlen) vtk_grid.SetPoints(vtk_p) for i in range(n_fields): vtk_grid.GetPointData().AddArray(vtk_fields[i]) #print(vtk_grid) writer = vtk.vtkXMLStructuredGridWriter() writer.SetFileName(result_filename) writer.SetInputData(vtk_grid) writer.Write()
def WriteVTSXMLVolumeFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTS XML grid file.')
if self.ApplyTransform == 0:
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(
(1 / spacing[0], 0, 0, -origin[0] / spacing[0], 0,
1 / spacing[1], 0, -origin[1] / spacing[1], 0, 0,
1 / spacing[2], -origin[2] / spacing[2], 0, 0, 0,
1)) #LPI convention with correct origin and spacing
else:
if self.RasToIjkMatrixCoefficients == None:
self.PrintError('Error: no RasToIjkMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
trans = vtk.vtkTransform()
trans.SetMatrix(matrix)
trans_filt = vtk.vtkTransformFilter()
trans_filt.SetTransform(trans)
trans_filt.SetInputData(self.Image)
trans_filt.Update()
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputConnection(trans_filt.GetOutputPort())
writer.SetFileName(self.OutputFileName)
writer.Write()
def _export(filename):
if len(filename) == 0:
raise ValueError("The output filename string is empty")
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetFileName(filename)
writer.SetInputData(self.block.mesh)
writer.Write()
def WriteVTSXMLVolumeFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTS XML grid file.')
if self.ApplyTransform == 0:
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy((1/spacing[0], 0, 0, - origin[0]/spacing[0],
0, 1/spacing[1], 0, - origin[1]/spacing[1],
0, 0, 1/spacing[2], - origin[2]/spacing[2],
0, 0, 0, 1)) #LPI convention with correct origin and spacing
else:
if self.RasToIjkMatrixCoefficients == None:
self.PrintError('Error: no RasToIjkMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
trans = vtk.vtkTransform()
trans.SetMatrix(matrix)
trans_filt = vtk.vtkTransformFilter()
trans_filt.SetTransform(trans)
trans_filt.SetInputData(self.Image)
trans_filt.Update()
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputConnection(trans_filt.GetOutputPort())
writer.SetFileName(self.OutputFileName)
writer.Write()
def compute_spect(basename, sfiles, nfiles):
print "VTS files are joined together via PVTS file into one global file."
for i in range(sfiles, nfiles + 1):
if (i < 10):
ext = "_000" + str(i)
elif (i < 100):
ext = "_00" + str(i)
elif (i < 1000):
ext = "_0" + str(i)
else:
ext = "_" + str(i)
filename = basename + ext + ".pvts"
if not (os.path.isfile(filename)):
print "ERROR in file: ", filename
print "file not found!"
break
reader = vtk.vtkXMLPStructuredGridReader()
reader.SetFileName(filename)
reader.Update()
mesh = reader.GetOutput()
#nx,ny,nz = mesh.GetDimensions()
#print nx, ny, nz
print "processing file: ", filename
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputData(mesh)
ofilename = "merged" + basename + ext + ".vts"
writer.SetFileName(ofilename)
writer.SetDataModeToAppended()
writer.Write()
print "finished!"
def export2vts(self, filename):
import vtk
grid = self.info['grid']
# Set grid points
points = vtk.vtkPoints()
for z in range(grid[2]):
for y in range(grid[1]):
for x in range(grid[0]):
points.InsertNextPoint([x, y, z])
struGrid = vtk.vtkStructuredGrid()
struGrid.SetDimensions(grid)
struGrid.SetPoints(points)
struGrid.Update()
# Set point data
grid_pt_num = struGrid.GetNumberOfPoints()
array = vtk.vtkIntArray()
array.SetNumberOfComponents(1) # this is 3 for a vector
array.SetNumberOfTuples(grid_pt_num)
array.SetName('MicrostructureID')
matPoint = self.microstructure.reshape([grid_pt_num])
for i in range(grid_pt_num):
array.SetValue(i, matPoint[i])
struGrid.GetPointData().AddArray(array)
struGrid.Update()
# Write output file
outWriter = vtk.vtkXMLStructuredGridWriter()
outWriter.SetDataModeToBinary()
outWriter.SetCompressorTypeToZLib()
outWriter.SetFileName(filename + '.vts')
outWriter.SetInput(struGrid)
outWriter.Update()
outWriter.Write()
def writeVTSFile(fileName, vtkStructuredGrid):
'''Function to write vtk structured grid (vts).'''
Writer = vtk.vtkXMLStructuredGridWriter()
if float(vtk.VTK_VERSION.split('.')[0]) >= 6:
Writer.SetInputData(vtkStructuredGrid)
else:
Writer.SetInput(vtkStructuredGrid)
Writer.SetFileName(fileName)
Writer.Update()
def WriteResultGrid(self, fileOutName):
'''
Write the current structured grid with resampled and added fields
to the specified file
'''
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputData(self.data)
writer.SetFileName(fileOutName)
writer.Write()
def writeVTSFile(fileName,vtkStructuredGrid):
'''Function to write vtk structured grid (vts).'''
Writer = vtk.vtkXMLStructuredGridWriter()
if float(vtk.VTK_VERSION.split('.')[0]) >=6:
Writer.SetInputData(vtkStructuredGrid)
else:
Writer.SetInput(vtkStructuredGrid)
Writer.SetFileName(fileName)
Writer.Update()
def writeVTKsgrid(filename,sgrid,compress=True):
w=vtk.vtkXMLStructuredGridWriter() #@UndefinedVariable
print 'Writing VTK file %s'%filename
w.SetFileName(filename)
w.SetInput(sgrid)
if compress:
w.SetCompressorTypeToZLib()
else:
w.SetCompressorTypeToNone()
w.Update()
w.Write()
def write_vtkxml_data(dataset, filepath):
if isinstance(dataset, vtk.vtkImageData):
writer = vtk.vtkXMLImageDataWriter()
elif isinstance(dataset, vtk.vtkStructuredGrid):
writer = vtk.vtkXMLStructuredGridWriter()
elif isinstance(dataset, vtk.vtkUnstructuredGrid):
writer = vtk.vtkXMLUnstructuredGridWriter()
elif isinstance(dataset, vtk.vtkPolyData):
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputData(dataset)
writer.SetFileName(filepath)
writer.Write()
def write_grid_to_file(grid: vtk.vtkStructuredGrid, output_grid: str):
"""Write vtkStructuredGrid to file
:param grid: Grid to write
:type grid: vtk.vtkStructuredGrid
:param output_grid: File path
:type output_grid: str
"""
LOGGER.debug("Writing to %s", output_grid)
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetFileName(output_grid)
writer.SetInputData(grid)
writer.Update()
def writePolyData(self, nfile):
if self.pitchAndRoll:
filename = '{}.{}.{}'.format(self.scanType, self.geomType, nfile)
else:
filename = '{}.{}.no-pitch-and-roll.{}'.format(
self.scanType, self.geomType, nfile)
if self.geomType == 'gates' or self.geomType == 'rays':
writer = vtk.vtkXMLPolyDataWriter()
filename += '.vtp'
elif self.geomType == 'sweep':
writer = vtk.vtkXMLStructuredGridWriter()
filename += '.vts'
writer.SetFileName(filename)
writer.SetInputData(self.scan)
writer.Write()
def write_files(self, path_out, eq_name):
###########################################################
# WRITE PLANE DATA
###########################################################
writer = vtk.vtkXMLPolyDataWriter()
writer.SetFileName(pjoin(path_out, 'Psi_n_' + eq_name + '_2D_x-y.vtp'))
writer.SetInputConnection(self.map2D.GetOutputPort())
writer.Write() # => Use for example ParaView to see scalars
###########################################################
# WRITE CYLINDER DATA
###########################################################
writer2 = vtk.vtkXMLStructuredGridWriter()
writer2.SetFileName(pjoin(path_out, 'Psi_n_' + eq_name + '_3D.vts'))
writer2.SetInputData(self.map3D)
writer2.Write() # => Use for example ParaView to see scalars
def writeVTKsg(self, ofn):
# Escritura en disco
off = vtk.vtkXMLStructuredGridWriter()
off.SetFileName(ofn)
# ASCII o binario (con o sin compresion)
off.SetDataModeToAscii()
# off.SetDataModeToBinary()
# off.SetCompressorTypeToZLib()
# Esto cambia con la version de VTK
t = self.getVTKsg()
self.meshtal.setVTKparams(t)
if vtk.vtkVersion().GetVTKMajorVersion() >= 6:
off.SetInputData(t)
else:
off.SetInput(t)
off.Write()
return
def write_polydata(input_data, filename, datatype=None):
"""
Write the given input data based on the file name extension.
Args:
input_data (vtkSTL/vtkPolyData/vtkXMLStructured/
vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
vtkXMLImage/Tecplot): Input data.
filename (str): Save path location.
datatype (str): Additional parameter for vtkIdList objects.
"""
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise RuntimeError('The file does not have an extension')
# Get writer
if fileType == 'stl':
writer = vtk.vtkSTLWriter()
elif fileType == 'vtk':
writer = vtk.vtkPolyDataWriter()
elif fileType == 'vts':
writer = vtk.vtkXMLStructuredGridWriter()
elif fileType == 'vtr':
writer = vtk.vtkXMLRectilinearGridWriter()
elif fileType == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif fileType == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
elif fileType == "vti":
writer = vtk.vtkXMLImageDataWriter()
elif fileType == "np" and datatype == "vtkIdList":
output_data = np.zeros(input_data.GetNumberOfIds())
for i in range(input_data.GetNumberOfIds()):
output_data[i] = input_data.GetId(i)
output_data.dump(filename)
return
else:
raise RuntimeError('Unknown file type %s' % fileType)
# Set filename and input
writer.SetFileName(filename)
writer.SetInputData(input_data)
writer.Update()
# Write
writer.Write()
def save__vtkStructuredGrid(structData=None,
DataFormat="binary",
outFile="out.vtp"):
# ------------------------------------------------- #
# --- [1] save in vtp File --- #
# ------------------------------------------------- #
writer = vtk.vtkXMLStructuredGridWriter()
if (DataFormat.lower() == "ascii"):
writer.SetDataModeToAscii()
if (DataFormat.lower() == "binary"):
writer.SetDataModeToBinary()
writer.SetFileName(outFile)
writer.SetInputData(structData)
writer.Write()
print("[save__vtkStructuredGrid] output :: {0} ".format(outFile))
return ()
def snapshot(self, snap_number):
# Сетка в терминах VTK
structuredGrid = vtk.vtkStructuredGrid()
# Точки сетки в терминах VTK
points = vtk.vtkPoints()
# Скалярное поле на точках сетки
smth = vtk.vtkDoubleArray()
smth.SetName("smth")
# Векторное поле на точках сетки
vel = vtk.vtkDoubleArray()
vel.SetNumberOfComponents(3)
vel.SetName("vel")
# Обходим все точки нашей расчётной сетки
# Делаем это максимально неэффективным, зато наглядным образом
number = len(self.nodes[0])
for i in range(0, number):
for j in range(0, number):
for k in range(0, number):
# Вставляем новую точку в сетку VTK-снапшота
points.InsertNextPoint(self.nodes[0][i, j, k],
self.nodes[1][i, j, k],
self.nodes[2][i, j, k])
# Добавляем значение скалярного поля в этой точке
smth.InsertNextValue(self.smth[i, j, k])
# Добавляем значение векторного поля в этой точке
vel.InsertNextTuple(
(self.velocity[0][i, j, k], self.velocity[1][i, j, k],
self.velocity[2][i, j, k]))
# Задаём размеры VTK-сетки (в точках, по трём осям)
structuredGrid.SetDimensions(number, number, number)
# Грузим точки в сетку
structuredGrid.SetPoints(points)
# Присоединяем векторное и скалярное поля к точкам
structuredGrid.GetPointData().AddArray(smth)
structuredGrid.GetPointData().AddArray(vel)
# Создаём снапшот в файле с заданным именем
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputDataObject(structuredGrid)
writer.SetFileName("s2/cubic3d-step-" + str(snap_number) + ".vts")
writer.Write()
def writeSGrid(sgrid, filename, verbose=0):
mypy.my_print(verbose, "*** writeSGrid: " + filename + " ***")
if ('vtk' in filename):
sgrid_writer = vtk.vtkStructuredGridWriter()
elif ('vts' in filename):
sgrid_writer = vtk.vtkXMLStructuredGridWriter()
else:
assert 0, "File must be .vtk or .vts. Aborting."
sgrid_writer.SetFileName(filename)
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
sgrid_writer.SetInputData(sgrid)
else:
sgrid_writer.SetInput(sgrid)
sgrid_writer.Update()
sgrid_writer.Write()
def write_3d_vector_fields_as_vtk_point_data(dat,result_filename,scale_factor=1.0): vtk_p = vtk.vtkPoints() x_vec, y_vec, z_vec = [np.array(x)*scale_factor for x in dat["grid_points"]] fields_dat = dat["fields"] xlen = len(x_vec) ylen = len(y_vec) zlen = len(z_vec) vtk_fields = [] for fi in fields_dat: vfi = vtk.vtkDoubleArray() vfi.SetNumberOfComponents(3) vfi.SetName(fi['name']) vtk_fields.append(vfi) n_fields = len(vtk_fields) #x_dat = fields_dat[component_indices[0]]['data'] #y_dat = fields_dat[component_indices[1]]['data'] #z_dat = fields_dat[component_indices[2]]['data'] for zi in range(zlen): for yi in range(ylen): for xi in range(xlen): vtk_p.InsertNextPoint([x_vec[xi], y_vec[yi], z_vec[zi]]) for i in range(n_fields): vtk_fields[i].InsertNextTuple([ fields_dat[i]['data'][0][xi, yi, zi], fields_dat[i]['data'][1][xi, yi, zi], fields_dat[i]['data'][2][xi, yi, zi] ]) vtk_grid = vtk.vtkStructuredGrid() vtk_grid.SetDimensions(xlen,ylen,zlen) vtk_grid.SetPoints(vtk_p) for i in range(n_fields): vtk_grid.GetPointData().AddArray(vtk_fields[i]) #print(vtk_grid) writer = vtk.vtkXMLStructuredGridWriter() writer.SetFileName(result_filename) writer.SetInputData(vtk_grid) writer.Write()
def savePolydata(polydata, file_name, binary=False, color_array_name=None):
""" Save a vtk polydata to a supported format file
Parameters
----------
polydata : vtkPolyData
file_name : string
"""
# get file extension (type)
file_extension = file_name.split(".")[-1].lower()
if file_extension == "vtk":
writer = vtk.vtkPolyDataWriter()
elif file_extension == "fib":
writer = vtk.vtkPolyDataWriter()
elif file_extension == "ply":
writer = vtk.vtkPLYWriter()
elif file_extension == "stl":
writer = vtk.vtkSTLWriter()
elif file_extension == "xml":
writer = vtk.vtkXMLPolyDataWriter()
elif file_extension == "vtp":
writer = vtk.vtkXMLPolyDataWriter()
elif file_extension == "vti":
writer = vtk.vtkXMLImageDataWriter()
elif file_extension == "vts":
writer = vtk.vtkXMLStructuredGridWriter()
elif file_extension == "vtu":
writer = vtk.vtkXMLUnstructuredGridWriter()
elif file_extension == "vtr":
writer = vtk.vtkXMLRectilinearGridWriter()
elif file_extension == "obj":
raise Exception("mni obj or Wavefront obj ?")
writer.SetFileName(file_name)
writer.SetInputData(polydata)
if color_array_name is not None:
writer.SetArrayName(color_array_name)
if binary:
writer.SetFileTypeToBinary()
writer.Update()
writer.Write()
def save(self, filename, binary=True):
"""
Writes a structured 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
".vts" 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.vtkStructuredGridWriter()
if binary:
writer.SetFileTypeToBinary()
else:
writer.SetFileTypeToASCII()
elif '.vts' in filename:
writer = vtk.vtkXMLStructuredGridWriter()
if binary:
writer.SetDataModeToBinary()
else:
writer.SetDataModeToAscii()
else:
raise Exception('Extension should be either ".vts" (xml) or' +
'".vtk" (legacy)')
# Write
writer.SetFileName(filename)
writer.SetInputData(self)
writer.Write()
def plotWithVTK(n, x, u):
# Stockage des donnees au format VTK
pts = vtk.vtkPoints()
pts.SetData(numpy_support.numpy_to_vtk(x))
uvtk = numpy_support.numpy_to_vtk(u)
uvtk.SetName("u")
data = vtk.vtkStructuredGrid()
nn = n + [1]*(3 - len(n))
data.SetDimensions(nn)
data.SetPoints(pts)
data.GetPointData().SetScalars(uvtk)
data.Update()
# Sortie fichier
w = vtk.vtkXMLStructuredGridWriter()
w.SetFileName("poisson.vts")
w.SetInput(data)
w.Write()
def convert__pointData2vts( self, tag=None ):
# ------------------------------------------------- #
# --- [1] Arguments Check --- #
# ------------------------------------------------- #
if ( tag is None ): sys.exit( "[convert__pointData2vts -@vtkDataManager-] tag == ???" )
if ( self.Data[tag].fieldData is None ):
self.Data[tag].generate__fieldData()
if ( self.Data[tag].coordinateData is None ):
self.Data[tag].generate__coordinateData()
# ------------------------------------------------- #
# --- [2] Coordinates Points Settings --- #
# ------------------------------------------------- #
coordinates_ = vtknp.numpy_to_vtk( self.Data[tag].coordinateData, deep=True )
points = vtk.vtkPoints()
points.SetData( coordinates_ )
self.sGrid.SetPoints( points )
# ------------------------------------------------- #
# --- [3] store points & pointData --- #
# ------------------------------------------------- #
for ik in range( self.Data[tag].nFields ):
pointData_ = vtknp.numpy_to_vtk( self.Data[tag].fieldData[:,ik], deep=True )
pointData_.SetName( self.Data[tag].fieldLabel[ik] )
self.sGrid.GetPointData().AddArray( pointData_ )
self.sGrid.SetExtent ( self.Data[tag].Extent )
# ------------------------------------------------- #
# --- [4] save in vtu File --- #
# ------------------------------------------------- #
writer = vtk.vtkXMLStructuredGridWriter()
if ( self.DataFormat.lower() == "ascii" ):
writer.SetDataModeToAscii()
if ( self.DataFormat.lower() == "binary" ):
writer.SetDataModeToBinary()
writer.SetFileName( self.vtkFile )
writer.SetInputData( self.sGrid )
writer.Write()
print( "[vtkDataConverter] output :: {0} ".format( self.vtkFile ) )
# Create a reader and write out the field combReader = vtk.vtkMultiBlockPLOT3DReader() combReader.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") combReader.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") combReader.SetScalarFunctionNumber(100) combReader.Update() output = combReader.GetOutput().GetBlock(0) # extract to reduce extents of grid extract = vtk.vtkExtractGrid() extract.SetInputData(output) extract.SetVOI(0, 28, 0, 32, 0, 24) extract.Update() # write just a piece (extracted piece) as well as the whole thing gridWriter = vtk.vtkXMLStructuredGridWriter() gridWriter.SetFileName(file0) gridWriter.SetInputConnection(extract.GetOutputPort()) gridWriter.SetDataModeToAscii() gridWriter.Write() gridWriter.SetInputData(output) gridWriter.SetFileName(file1) gridWriter.SetDataModeToAppended() gridWriter.SetNumberOfPieces(2) gridWriter.Write() gridWriter.SetFileName(file2) gridWriter.SetDataModeToBinary() gridWriter.SetWriteExtent(8, 56, 4, 16, 1, 24) gridWriter.Write()
def _mri_hd5_to_structured_grids(hd5, name, save_path=None, order='F'):
"""
Returns MRI tensors as list of VTK structured grids aligned to the reference system of the patient
"""
arr = _mri_tensor_4d(hd5, name)
width = hd5['_'.join([MRI_PIXEL_WIDTH, name])]
height = hd5['_'.join([MRI_PIXEL_HEIGHT, name])]
positions = mri_tensor_2d(hd5, '_'.join([MRI_PATIENT_POSITION, name]))
orientations = mri_tensor_2d(
hd5,
'_'.join([MRI_PATIENT_ORIENTATION, name]),
)
thickness = hd5['_'.join([MRI_SLICE_THICKNESS, name])]
_, dataset_indices, dataset_counts = np.unique(
orientations,
axis=1,
return_index=True,
return_counts=True,
)
grids = []
for d_idx, d_cnt in zip(dataset_indices, dataset_counts):
grids.append(vtk.vtkStructuredGrid())
nslices = d_cnt
# If multislice, override thickness as distance between voxel centers. Note: removes eventual gaps between slices
if nslices > 1:
thickness = np.linalg.norm(
positions[:, d_idx] - positions[:, d_idx + 1], )
transform = vtk.vtkTransform()
n_orientation = np.cross(
orientations[3:, d_idx],
orientations[:3, d_idx],
)
# 4x4 transform matrix to align to the patient reference system
transform.SetMatrix([
orientations[3, d_idx] * height,
orientations[0, d_idx] * width,
n_orientation[0] * thickness,
positions[0, d_idx],
orientations[4, d_idx] * height,
orientations[1, d_idx] * width,
n_orientation[1] * thickness,
positions[1, d_idx],
orientations[5, d_idx] * height,
orientations[2, d_idx] * width,
n_orientation[2] * thickness,
positions[2, d_idx],
0,
0,
0,
1,
])
x_coors = np.arange(0, arr.shape[0] + 1) - 0.5
y_coors = np.arange(0, arr.shape[1] + 1) - 0.5
z_coors = np.arange(0, d_cnt + 1) - 0.5
xyz_meshgrid = np.meshgrid(x_coors, y_coors, z_coors)
xyz_pts = np.zeros(
((arr.shape[0] + 1) * (arr.shape[1] + 1) * (d_cnt + 1), 3), )
for dim in range(3):
xyz_pts[:, dim] = xyz_meshgrid[dim].ravel(order=order)
vtk_pts = vtk.vtkPoints()
vtk_pts.SetData(vtk.util.numpy_support.numpy_to_vtk(xyz_pts))
grids[-1].SetPoints(vtk_pts)
grids[-1].SetDimensions(len(x_coors), len(y_coors), len(z_coors))
grids[-1].SetExtent(
0,
len(x_coors) - 1,
0,
len(y_coors) - 1,
0,
len(z_coors) - 1,
)
for t in range(MRI_FRAMES):
arr_vtk = vtk.util.numpy_support.numpy_to_vtk(
arr[:, :, d_idx:d_idx + d_cnt, t].ravel(order=order),
deep=True,
)
arr_vtk.SetName(f'{name}_{t}')
grids[-1].GetCellData().AddArray(arr_vtk)
transform_filter = vtk.vtkTransformFilter()
transform_filter.SetInputData(grids[-1])
transform_filter.SetTransform(transform)
transform_filter.Update()
grids[-1].DeepCopy(transform_filter.GetOutput())
if save_path:
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetFileName(
os.path.join(save_path, f'grid_{name}_{d_idx}.vts'), )
writer.SetInputData(grids[-1])
writer.Update()
return grids
combReader = vtk.vtkMultiBlockPLOT3DReader() combReader.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") combReader.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") combReader.SetScalarFunctionNumber(100) combReader.Update() output = combReader.GetOutput().GetBlock(0) # extract to reduce extents of grid extract = vtk.vtkExtractGrid() extract.SetInputData(output) extract.SetVOI(0, 28, 0, 32, 0, 24) extract.Update() # write just a piece (extracted piece) as well as the whole thing gridWriter = vtk.vtkXMLStructuredGridWriter() gridWriter.SetFileName(file0) gridWriter.SetInputConnection(extract.GetOutputPort()) gridWriter.SetDataModeToAscii() gridWriter.Write() gridWriter.SetInputData(output) gridWriter.SetFileName(file1) gridWriter.SetDataModeToAppended() gridWriter.SetNumberOfPieces(2) gridWriter.Write() gridWriter.SetFileName(file2) gridWriter.SetDataModeToBinary() gridWriter.SetWriteExtent(8, 56, 4, 16, 1, 24) gridWriter.Write()
def MPB_h5tovts(h5file, basepath, total_lattice_size=None, requested_dataset=[], verbosity=0):
'''
* total_lattice_size : total length of the lattice vectors, i.e. **size*basis-size** in MPB terms. Overrides any values obtained from reading the lattice vectors in the .h5 file.
.. todo:: Emulate the -x/y/z options of mpb-data, i.e. create a periodic structure from a unit-cell.
'''
# read in .h5 file
with h5py.File(h5file, "r") as HDF5_file_object:
print('Reading from ' + h5file)
(mylattice, complete_dataset_list) = h5_setupLattice(HDF5_file_object, total_lattice_size, requested_dataset)
(Nx, Ny, Nz) = mylattice.getResolution()
(a1, a2, a3) = mylattice.getLatticeVectors()
(xmesh, ymesh, zmesh) = mylattice.getMesh()
# create the vtkPoints structure for the coordinates
points = vtk.vtkPoints()
points.SetNumberOfPoints(Nx*Ny*Nz)
if requested_dataset:
dataset_list = requested_dataset
else:
dataset_list = complete_dataset_list
# create the vtkScalarArray structures for the data
dataset_dict = dict()
for key in dataset_list:
print('key = {}'.format(key))
try:
# We need flat 1D data for VTK structures (and for numpy_to_vtk). Equivalent ways of achieving this:
# A.reshape(-1, order='F')
# A.flatten(order='F')
# A.ravel(order='F')
# ‘F’ means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. (VTK style)
#scalar = HDF5_file_object[key][...].transpose().reshape(-1,1) # OK
#scalar = HDF5_file_object[key][...].reshape(-1,1, order='F') # fail
#scalar = HDF5_file_object[key][...].reshape(-1, order='F') # OK
scalar = HDF5_file_object[key][...].flatten(order='F') # OK
#scalar = HDF5_file_object[key][...].ravel(order='F') # OK
except:
print('scalar = {}'.format(scalar))
print('In case of this error: TypeError: CreateDataArray argument 1: an integer is required')
print('Just make sure to use the --bfdtd option, until auto-detection arrives.')
raise
vtk_data = numpy_to_vtk(scalar)
#vtk_data = vtkScalarArray()
vtk_data.SetName(key)
#vtk_data.SetNumberOfTuples(Nx*Ny*Nz)
dataset_dict[key] = (HDF5_file_object[key], vtk_data, scalar)
last_info_time = time.time()
print('Starting loops')
counter = 0
# fill the vtkPoints and vtkScalarArray
for k in range(Nz):
for j in range(Ny):
for i in range(Nx):
offset = i + j*Nx + k*Nx*Ny
# old system:
# coord = (i/(Nx-1) - 0.5)*a1 + (j/(Ny-1) - 0.5)*a2 + (k/(Nz-1) - 0.5)*a3
# new system:
coord = xmesh[i]*a1 + ymesh[j]*a2 + zmesh[k]*a3
points.SetPoint(offset, coord)
#for key in dataset_dict.keys():
#dataset_dict[key][1].SetTuple1(offset, dataset_dict[key][0][i,j,k])
#InsertTuples
#virtual void vtkAbstractArray::InsertTuples ( vtkIdList * dstIds,
#vtkIdList * srcIds,
#vtkAbstractArray * source
#) [pure virtual]
if time.time() - last_info_time > 5:
print('{} %'.format(100*offset/(Nx*Ny*Nz-1)))
last_info_time = time.time()
if verbosity>1:
counter += 1
progress_str = 'Progress: {}/{}'.format(counter, Nx*Ny*Nz)
#print(progress_str, end='\r')
print(progress_str)
#subprocess.call(["printf", progress_str+'\r'])
print('\nLoops done.')
#for key in dataset_dict.keys():
#h5_data = dataset_dict[key][0]
#vtk_data = dataset_dict[key][1]
#vtk_data.InsertTuples()
#.SetTuple1(offset, [i,j,k])
# create structured grid
dataset_vts = vtk.vtkStructuredGrid()
dataset_vts.SetDimensions(Nx, Ny, Nz)
dataset_vts.SetPoints(points)
# create vtkImageData
dataset_vti = vtk.vtkImageData()
dataset_vti.SetDimensions(Nx, Ny, Nz)
(xmin,xmax, ymin,ymax, zmin,zmax) = mylattice.getBounds()
dataset_vti.SetOrigin([xmin, ymin, zmin])
dataset_vti.SetSpacing(mylattice.getSpacing())
# add scalar data to the grids
for key in dataset_dict.keys():
dataset_vts.GetPointData().AddArray(dataset_dict[key][1])
dataset_vti.GetPointData().AddArray(dataset_dict[key][1])
dataset_vts.GetPointData().SetActiveScalars('data')
dataset_vti.GetPointData().SetActiveScalars('data')
# write out .vts file
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputData(dataset_vts)
writer.SetFileName(basepath + '.' + writer.GetDefaultFileExtension())
writer.Write()
# write out .vti file
writer = vtk.vtkXMLImageDataWriter()
writer.SetInputData(dataset_vti)
writer.SetFileName(basepath + '.' + writer.GetDefaultFileExtension())
writer.Write()
return
def stl_to_vts_and_h5(implicit_function, outfile_basename, lattice, epsilon_inside, epsilon_outside):
(Nx, Ny, Nz) = lattice.getResolution()
(a1, a2, a3) = lattice.getLatticeVectors()
points = vtk.vtkPoints()
points.SetNumberOfPoints(Nx*Ny*Nz)
scalars_vtk = vtkScalarArray()
scalars_vtk.SetNumberOfTuples(Nx*Ny*Nz)
scalars_numpy = zeros([Nx,Ny,Nz])
print('=== dims ===')
print(scalars_numpy.shape)
last_info_time = time.time()
print('=== Loop start ===')
for k in range(Nz):
for j in range(Ny):
for i in range(Nx):
coord = (i/(Nx-1) - 0.5)*a1 + (j/(Ny-1) - 0.5)*a2 + (k/(Nz-1) - 0.5)*a3
offset = i + j*Nx + k*Nx*Ny
points.SetPoint(offset, coord)
if implicit_function.FunctionValue(coord) <= 0:
value = epsilon_inside
else:
value = epsilon_outside
scalars_vtk.SetTuple1(offset, value)
scalars_numpy[i, j, k] = value
if time.time() - last_info_time > 5:
print('{} %'.format(100*offset/(Nx*Ny*Nz-1)))
last_info_time = time.time()
print('=== Loop end ===')
dataset = vtk.vtkStructuredGrid()
dataset.SetDimensions(Nx, Ny, Nz)
dataset.SetPoints(points)
dataset.GetPointData().SetScalars(scalars_vtk)
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputData(dataset)
writer.SetFileName(outfile_basename + '.' + writer.GetDefaultFileExtension())
writer.Write()
h5file = outfile_basename + '.h5'
with h5py.File(h5file, "w") as HDF5_file_object:
print('writing to ' + h5file)
dset = HDF5_file_object.create_dataset('/data', scalars_numpy.shape, dtype=numpy.float64)
dset[...] = scalars_numpy
dset = HDF5_file_object.create_dataset("description", (), dtype="S29")
dset[...] = 'dielectric function, epsilon'
lattice_vectors = numpy.array([a1, a2, a3])
print(lattice_vectors)
dset = HDF5_file_object.create_dataset('/lattice vectors', lattice_vectors.shape, dtype=numpy.float64)
dset[...] = lattice_vectors
# TODO: Add these fields:
#epsilon.xx Dataset {100, 100, 100}
#epsilon.xy Dataset {100, 100, 100}
#epsilon.xz Dataset {100, 100, 100}
#epsilon.yy Dataset {100, 100, 100}
#epsilon.yz Dataset {100, 100, 100}
#epsilon.zz Dataset {100, 100, 100}
#epsilon_inverse.xx Dataset {100, 100, 100}
#epsilon_inverse.xy Dataset {100, 100, 100}
#epsilon_inverse.xz Dataset {100, 100, 100}
#epsilon_inverse.yy Dataset {100, 100, 100}
#epsilon_inverse.yz Dataset {100, 100, 100}
#epsilon_inverse.zz Dataset {100, 100, 100}
return
def loadSUTRA():
# x y z
points = np.array((X[:, 2], X[:, 3], 1e1 * X[:, 4])).T
#hull = ConvexHull( points , incremental=True)
#for simplex in hull.simplices:
# plt.plot(points[simplex, 0], points[simplex, 1], 'k-', markersize=1)
nnodes = np.shape(points)[0]
uGrid = vtk.vtkUnstructuredGrid()
sGrid = vtk.vtkStructuredGrid()
vtk_points = vtk.vtkPoints()
vtk_spoints = vtk.vtkPoints(
) # structured points need to be in a different order
for point in range(np.shape(points)[0]):
vtk_points.InsertNextPoint(points[point, 0], points[point, 1],
points[point, 2])
uGrid.SetPoints(vtk_points)
sGrid.SetPoints(vtk_points)
sGrid.SetDimensions(124, 88, 4)
# Read in the connections
# Format is as follows
# nodeid p0, p1, p2, p3, p4, p5, p6, p7, p8
C = np.loadtxt("incident", comments="#", skiprows=2, dtype=int)
#for line in range(1):
for line in range(np.shape(C)[0]):
idList = vtk.vtkIdList()
#x = []
#y = []
for node in C[line, :][1:]:
#x.append( X[node,2] )
#y.append( X[node,3] )
idList.InsertNextId(node - 1)
uGrid.InsertNextCell(vtk.VTK_HEXAHEDRON, idList)
# Stuff permeability cell data
k = np.loadtxt("element_Sperm", comments="#")
kx = vtk.vtkDoubleArray()
kx.SetName("$\kappa_x$")
ky = vtk.vtkDoubleArray()
ky.SetName("$\kappa_y$")
kz = vtk.vtkDoubleArray()
kz.SetName("$\kappa_z$")
for ik, K in enumerate(k):
kx.InsertNextTuple1(K[2])
ky.InsertNextTuple1(K[3])
kz.InsertNextTuple1(K[4])
uGrid.GetCellData().AddArray(kx)
uGrid.GetCellData().AddArray(ky)
uGrid.GetCellData().AddArray(kz)
# Stuff porosity node data
phi = np.loadtxt("node_Spor")
vphi = vtk.vtkDoubleArray()
vphi.SetName("$\phi$")
for ik, K in enumerate(phi):
vphi.InsertNextTuple1(K[5])
uGrid.GetPointData().AddArray(vphi)
# Stuff Pressure node data
P = np.loadtxt("../InjModel7/Inj7.nod", comments="#")
vP = vtk.vtkDoubleArray()
vP.SetName("$P$")
for ik in range(nnodes):
vP.InsertNextTuple1(P[2 * nnodes + ik, 3])
uGrid.GetPointData().AddArray(vP)
uWrite = vtk.vtkXMLUnstructuredGridWriter()
uWrite.SetInputData(uGrid)
uWrite.SetFileName("sutra.vtu")
uWrite.Write()
sWrite = vtk.vtkXMLStructuredGridWriter()
sWrite.SetInputData(sGrid)
sWrite.SetFileName("sutra.vts")
sWrite.Write()
def write(self, fn):
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetFileName(fn+".vts")
writer.SetInputData(self.vtkStructuredGrid)
writer.Write()
def writeVTSFile(fileName,vtkStructuredGrid): '''Function to write vtk structured grid (vts).''' Writer = vtk.vtkXMLStructuredGridWriter() Writer.SetInput(vtkStructuredGrid) Writer.SetFileName(fileName) Writer.Update()
def write_polydata(input_data, filename, datatype=None, file_type="ascii"):
"""
Write the given input data based on the file name extension.
Args:
file_type (string): Filetype of output
input_data (vtkSTL/vtkPolyData/vtkXMLStructured/
vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
vtkXMLImage/Tecplot): Input data.
filename (str): Save path location.
datatype (str): Additional parameter for vtkIdList objects.
"""
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise RuntimeError('The file does not have an extension')
# Get writer
if fileType == 'stl':
writer = vtk.vtkSTLWriter()
elif fileType == 'vtk':
# Set reader based on data type
if isinstance(input_data, vtk.vtkUnstructuredGrid):
writer = vtk.vtkUnstructuredGridWriter()
elif isinstance(input_data, vtk.vtkStructuredGrid):
writer = vtk.vtkStructuredGridWriter()
elif isinstance(input_data, vtk.vtkRectilinearGrid):
writer = vtk.vtkRectilinearGridWriter()
elif isinstance(input_data, vtk.vtkStructuredPoints) or \
isinstance(input_data, vtk.vtkImageData):
writer = vtk.vtkStructuredPointsWriter()
elif isinstance(input_data, vtk.vtkPolyData):
writer = vtk.vtkPolyDataWriter()
if file_type.lower() == "ascii":
writer.SetFileType(1)
elif file_type.lower() == "binary":
writer.SetFileType(0)
else:
raise ValueError("Invalid file type, can only be ascii or binary")
elif fileType == 'vts':
writer = vtk.vtkXMLStructuredGridWriter()
elif fileType == 'vtr':
writer = vtk.vtkXMLRectilinearGridWriter()
elif fileType == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif fileType == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
elif fileType == "vti":
writer = vtk.vtkXMLImageDataWriter()
elif fileType == "np" and datatype == "vtkIdList":
output_data = np.zeros(input_data.GetNumberOfIds())
for i in range(input_data.GetNumberOfIds()):
output_data[i] = input_data.GetId(i)
output_data.dump(filename)
return
else:
raise RuntimeError('Unknown file type %s' % fileType)
# Set filename and input
writer.SetFileName(filename)
writer.SetInputData(input_data)
writer.Update()
# Write
writer.Write()
