def Create_Topo(Slope,Plane): ugrid = vtk.vtkUnstructuredGrid() gridreader=vtk.vtkUnstructuredGridReader() gridreader.SetFileName(Slope) gridreader.Update() ugrid = gridreader.GetOutput() GeomFilt1 = vtk.vtkGeometryFilter() GeomFilt1.SetInput(ugrid) GeomFilt1.Update() x = GeomFilt1.GetOutput() u = vtk.vtkUnstructuredGrid() bgridreader=vtk.vtkXMLUnstructuredGridReader() bgridreader.SetFileName(Plane) bgridreader.Update() u = bgridreader.GetOutput() GeomFilt2 = vtk.vtkGeometryFilter() GeomFilt2.SetInput(u) GeomFilt2.Update() y = GeomFilt2.GetOutput() append = vtk.vtkAppendPolyData() append.AddInput(x) append.AddInput(y) data = append.GetOutput() d = vtk.vtkDelaunay3D() d.SetInput(data) d.Update d.BoundingTriangulationOff() d.SetTolerance(0.00001) d.SetAlpha(0) d.Update() z = d.GetOutput() return z
def Creating_z(Plane,Slope,Sediment,Start_time,End_time,Time_step):
vtuObject = vtktools.vtu(Plane)
vtuObject.GetFieldNames()
gradient = vtuObject.GetScalarField('u')
ugrid = vtk.vtkUnstructuredGrid()
gridreader=vtk.vtkXMLUnstructuredGridReader()
gridreader.SetFileName(Plane)
gridreader.Update()
ugrid = gridreader.GetOutput()
points = ugrid.GetPoints()
nPoints = ugrid.GetNumberOfPoints()
for p in range(0,nPoints):
x = (points.GetPoint(p)[:2] + (gradient[p],))
points.SetPoint(p,x)
ugrid.Update()
###################################################################################################################
t = Start_time
dt = Time_step
et = End_time
while t <= et:
Import = Sediment + str(t) +'000000.vtu'
NewSave = Sediment + str(t) + '_sed_slope.pvd'
vtuObjectSed = vtktools.vtu(Import)
vtuObjectSed.GetFieldNames()
gradientSed = vtuObjectSed.GetScalarField('u')
sedgrid = vtk.vtkUnstructuredGrid()
sedgridreader=vtk.vtkXMLUnstructuredGridReader()
sedgridreader.SetFileName(Import)
sedgridreader.Update()
sedgrid = sedgridreader.GetOutput()
s = sedgrid.GetPoints()
for p in range(0,nPoints):
x = ((s.GetPoint(p)[0],) + (s.GetPoint(p)[1],) + ((gradientSed[p]+gradient[p]),))
s.SetPoint(p,x)
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(NewSave)
writer.SetInput(sedgrid)
writer.Update()
writer.Write()
t += dt
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileName(Slope)
writer.SetInput(ugrid)
writer.Update()
writer.Write()
def compare_files_vtu(first_file, second_file, file_type, tolerance=1e-12):
import vtk
# read files:
if file_type == "vtu":
reader1 = vtk.vtkXMLUnstructuredGridReader()
reader2 = vtk.vtkXMLUnstructuredGridReader()
else:
reader1 = vtk.vtkXMLPUnstructuredGridReader()
reader2 = vtk.vtkXMLPUnstructuredGridReader()
reader1.SetFileName(first_file)
reader1.Update()
output1 = reader1.GetOutput()
reader2.SetFileName(second_file)
reader2.Update()
output2 = reader2.GetOutput()
# check fidelity
point_data1 = output1.GetPointData()
point_data2 = output2.GetPointData()
# verify same number of PointData arrays in both files
if point_data1.GetNumberOfArrays() != point_data2.GetNumberOfArrays():
print("File 1:", point_data1.GetNumberOfArrays(), "\n", "File 2:",
point_data2.GetNumberOfArrays())
raise ValueError("Fidelity test failed: Mismatched data array count")
for i in range(point_data1.GetNumberOfArrays()):
arr1 = point_data1.GetArray(i)
arr2 = point_data2.GetArray(i)
# verify both files contain same arrays
if point_data1.GetArrayName(i) != point_data2.GetArrayName(i):
print("File 1:", point_data1.GetArrayName(i), "\n", "File 2:",
point_data2.GetArrayName(i))
raise ValueError(
"Fidelity test failed: Mismatched data array names")
# verify arrays are same sizes in both files
if arr1.GetSize() != arr2.GetSize():
print("File 1, DataArray", i, ":", arr1.GetSize(), "\n",
"File 2, DataArray", i, ":", arr2.GetSize())
raise ValueError(
"Fidelity test failed: Mismatched data array sizes")
# verify individual values w/in given tolerance
for j in range(arr1.GetSize()):
if abs(arr1.GetValue(j) - arr2.GetValue(j)) > tolerance:
print("Tolerance:", tolerance)
raise ValueError(
"Fidelity test failed: Mismatched data array values with given tolerance"
)
print("VTU Fidelity test completed successfully with tolerance", tolerance)
def read_vtk_file(filename, vtuFile=True):
### 1.1 Read data
if vtuFile: # read vtu file
reader = vtk.vtkXMLUnstructuredGridReader()
else: # read vtk file
reader = vtk.vtkUnstructuredGridReader()
gridreader = vtk.vtkXMLUnstructuredGridReader()
gridreader.SetFileName(filename)
gridreader.Update()
vtkOut = gridreader.GetOutput() # get an vtkUnstructuredGridReader
return vtkOut
def Slice_VTK_data_to_VTK(inputFileName,
outputFileName,
point, normal,
resolution
):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(inputFileName)
reader.Update()
plane = vtk.vtkPlane()
plane.SetOrigin(point)
plane.SetNormal(normal)
cutter = vtk.vtkFiltersCorePython.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(reader.GetOutputPort())
cutter.Update()
#Convert tht polydata structure générated by cutter into unstructured grid by triangulation
triFilter = vtk.vtkDataSetTriangleFilter()
triFilter.SetInputConnection(cutter.GetOutputPort())
triFilter.Update()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(triFilter.GetOutput())
writer.SetFileName(outputFileName)
writer.Write()
def __init__(self,offset,get=1,file='data',type='vtu',mirrorPlane=None,silent=0):
self.offset=offset
self.filenameout = file
self.type = type
self.isLoaded = False
self.mirrorPlane=mirrorPlane
self.silent = silent
if type == 'vtu':
self.filename=''.join([self.filenameout,repr(offset).zfill(4),'.vtu'])
self.datareader = v.vtkXMLUnstructuredGridReader()
elif type == 'pvtu':
self.filename=''.join([self.filenameout,repr(offset).zfill(4),'.pvtu'])
self.datareader = v.vtkXMLPUnstructuredGridReader()
elif type == 'vti':
self.filename=''.join([self.filenameout,repr(offset).zfill(4),'.vti'])
self.datareader = v.vtkXMLImageDataReader()
else:
print 'Unknown filetype'
if (self.silent == 0): print '========================================'
if (self.silent == 0): print 'loading file %s' % (self.filename)
if get != None:
self.getAll()
def read_vtu(name):
""" Opens a vtp and returns the vtkUnstructuredGrid class """
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(name)
reader.Update()
ug = reader.GetOutput()
return ug
def load_vtk_structured(self, file_name):
self.fname = file_name
#reader = vtk.vtkUnstructuredGridReader()
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update()
#reader = vtk.vtkOpenFOAMReader()
#numberOfCellArrays = reader.GetNumberOfCellArrays();
#for i in range(numberOfCellArrays):
# print reader.GetCellArrayName(i)
self.output = reader.GetOutput()
self.vtk_pts = self.output.GetPointData()
self.vtk_n_pts = self.output.GetNumberOfPoints()
self.vtk_n_cells = self.output.GetNumberOfCells()
self.vtk_n_props = self.vtk_pts.GetNumberOfArrays()
self.reader = reader
#get_range = self.output.GetScalarRange()
#print get_range
print " [Vtk_unstructured_reader]:"
print " Cells: %d" % (self.vtk_n_cells)
print " Point: %d" % (self.vtk_n_pts)
print " Props: ",
for i in range(self.vtk_n_props):
print "\'%s\'" % (self.vtk_pts.GetArrayName(i)),
print
def create_probe(filename):
if (verbose):
print "Creating probe from ", filename
pd = vtk.vtkStructuredPoints()
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
ugrid = reader.GetOutput()
ugrid.Update()
b = ugrid.GetBounds()
pd.SetOrigin(b[0], b[2], b[4])
l = [b[1] - b[0], b[3] - b[2], b[5] - b[4]]
tot_len = float(l[0] + l[1] + l[2])
dims = intervals
pd.SetExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
pd.SetUpdateExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
pd.SetWholeExtent(0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1)
pd.SetDimensions(dims)
dims = [max(1, x - 1) for x in dims]
l = [max(1e-3, x) for x in l]
sp = [l[0] / dims[0], l[1] / dims[1], l[2] / dims[2]]
pd.SetSpacing(sp)
return pd
def vtu_readvf3d(name):
#generate reader and read file
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(name)
reader.Update()
vtkdata = reader.GetOutput()
#Obtain vectors and points from data in file
nPoints = vtkdata.GetNumberOfPoints()
pointData = vtkdata.GetPointData()
vectorData = pointData.GetVectors()
scalarData = pointData.GetScalars()
try:
vect_list = vtk2np(vectorData)
except AttributeError:
print 'there is no vector data'
vect_list = None
try:
scal_list = vtk2np(scalarData)
except AttributeError:
#print 'there is no scalar data'
scal_list = None
pnts_list = N.array([vtkdata.GetPoint(i) for i in range(nPoints)])
#rearange data to 3d matices
bounds = vtkdata.GetBounds()#(Xmin,Xmax,Ymin,Ymax,Zmin,Zmax)
[X,Y,Z,U,V,W] = ijk(pnts_list,bounds,vect_list)
return [X,Y,Z,U,V,W]
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkXMLUnstructuredGridReader(), 'Reading vtkXMLUnstructuredGrid.',
(), ('vtkXMLUnstructuredGrid',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, comm, particle_vtu_file):
self.comm = comm
self.rank = comm.Get_rank()
self.numberOfProcessors = self.comm.Get_size()
'''
***************** PARTICLES INJECTION PREPARATION ********************
'''
self.domain_particles = vtk.vtkXMLUnstructuredGridReader()
self.domain_particles.SetFileName(particle_vtu_file)
self.domain_particles.Update()
'''
We push the domain_particles through an append_filter (as the only
input) This will become useful later when we start reinjecting
particles - the new particles will be added as inputs to the
vtkAppendFilter.
'''
original_particle_mesh_data = self.domain_particles.GetOutput()
self.append_filter = vtk.vtkAppendFilter()
if vtk.VTK_MAJOR_VERSION <= 5:
self.append_filter.AddInput(original_particle_mesh_data)
else:
self.append_filter.AddInputData(original_particle_mesh_data)
self.append_filter.Update()
self.alive_particles_coordinates = np.copy(
numpy_support.vtk_to_numpy(
self.append_filter.GetOutput().GetPoints().GetData()))
# self.particles_vtk_pts = vtk.vtkPoints().SetData(
# numpy_support.numpy_to_vtk(self.alive_particles_coordinates))
self.nparticles = self.append_filter.GetOutput().GetNumberOfPoints()
# initially particles are 'tidy'
self.particles_indices = np.arange(self.nparticles, dtype=np.int64)
self.particles_offsets = np.zeros((self.numberOfProcessors + 1, ),
dtype=np.int64)
def get_particle_data(filename):
# load a vtk file as input
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
# Get the coordinates of nodes in the mesh
nodes_vtk_array = reader.GetOutput().GetPoints().GetData()
#The "Temperature" field is the third scalar in my vtk file
angle_vtk_array = reader.GetOutput().GetPointData().GetArray("angle")
angle_numpy_array = vtk_to_numpy(angle_vtk_array)
count_vtk_array = reader.GetOutput().GetPointData().GetArray("count")
count_numpy_array = vtk_to_numpy(count_vtk_array)
stokes_vtk_array = reader.GetOutput().GetPointData().GetArray(
"stokes_velocity")
stokes_numpy_array = vtk_to_numpy(stokes_vtk_array)
electro_vtk_array = reader.GetOutput().GetPointData().GetArray(
"electro_velocity")
electro_numpy_array = vtk_to_numpy(electro_vtk_array)
charge_vtk_array = reader.GetOutput().GetPointData().GetArray("charge")
charge_numpy_array = vtk_to_numpy(charge_vtk_array)
#Get the coordinates of the nodes and their temperatures
nodes_nummpy_array = vtk_to_numpy(nodes_vtk_array)
x, y, z = nodes_nummpy_array[:,
0], nodes_nummpy_array[:,
1], nodes_nummpy_array[:,
2]
return ParticlesData(x, y, angle_numpy_array, count_numpy_array,
stokes_numpy_array[:, 0], stokes_numpy_array[:, 1],
electro_numpy_array[:, 0], electro_numpy_array[:, 1],
charge_numpy_array)
def readUGrid(
filename,
verbose=1):
myVTK.myPrint(verbose, "*** readUGrid: " + filename + " ***")
if ('vtk' in filename):
ugrid_reader = vtk.vtkUnstructuredGridReader()
elif ('vtu' in filename):
ugrid_reader = vtk.vtkXMLUnstructuredGridReader()
else:
assert 0, "File must be .vtk or .vtu. Aborting."
assert (os.path.isfile(filename)), "Wrong filename. Aborting."
ugrid_reader.SetFileName(filename)
ugrid_reader.Update()
ugrid = ugrid_reader.GetOutput()
if (verbose):
n_points = ugrid.GetNumberOfPoints()
print 'n_points =', n_points
n_cells = ugrid.GetNumberOfCells()
print 'n_cells =', n_cells
return ugrid
def load_VTU(filename):
"""Loads VTK file format in the new XML format (vtu file extension for unstructured meshes).
It relies on the reader from the VTK library.
Parameters
----------
filename: str
name of the meh file on disk
Returns
-------
vertices: ndarray
numpy array of the coordinates of the mesh's nodes
faces: ndarray
numpy array of the faces' nodes connectivities
Note
----
VTU files have a 0-indexing
"""
_check_file(filename)
from vtk import vtkXMLUnstructuredGridReader
reader = vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_mesh = reader.GetOutput()
vertices, faces = _dump_vtk(vtk_mesh)
return vertices, faces
def load_vtk_mesh(fileName):
"""
Loads surface/volume mesh to VTK
"""
if (fileName == ''):
return 0
fn_dir, fn_ext = os.path.splitext(fileName)
if (fn_ext == '.vtk'):
print('Reading vtk with name: ', fileName)
reader = vtk.vtkPolyDataReader()
elif (fn_ext == '.vtp'):
print('Reading vtp with name: ', fileName)
reader = vtk.vtkXMLPolyDataReader()
elif (fn_ext == '.stl'):
print('Reading stl with name: ', fileName)
reader = vtk.vtkSTLReader()
elif (fn_ext == '.obj'):
print('Reading obj with name: ', fileName)
reader = vtk.vtkOBJReader()
elif (fn_ext == '.vtu'):
print('Reading vtu with name: ', fileName)
reader = vtk.vtkXMLUnstructuredGridReader()
elif (fn_ext == '.pvtu'):
print('Reading pvtu with name: ', fileName)
reader = vtk.vtkXMLPUnstructuredGridReader()
else:
print(fn_ext)
raise ValueError('File extension not supported')
reader.SetFileName(fileName)
reader.Update()
return reader.GetOutput()
def read(filetype, filename):
if filetype == 'vtk':
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_mesh = reader.GetOutput()
elif filetype == 'vtu':
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_mesh = reader.GetOutput()
elif filetype == 'exodus':
reader = vtk.vtkExodusIIReader()
reader.SetFileName(filename)
vtk_mesh = _read_exodusii_mesh(reader)
else:
raise RuntimeError('Unknown file type \'%s\'.' % filename)
# Explicitly extract points, cells, point data, field data
points = vtk.util.numpy_support.vtk_to_numpy(
vtk_mesh.GetPoints().GetData())
cells = _read_cells(vtk_mesh)
point_data = _read_data(vtk_mesh.GetPointData())
cell_data = _read_data(vtk_mesh.GetCellData())
field_data = _read_data(vtk_mesh.GetFieldData())
return points, cells, point_data, cell_data, field_data
def load_VTU(filename, name=None):
"""Loads VTK file format in the new XML format (vtu file extension for unstructured meshes).
It relies on the reader from the VTK library.
Parameters
----------
filename: str
name of the meh file on disk
Returns
-------
Mesh
the loaded mesh
Note
----
VTU files have a 0-indexing
"""
_check_file(filename)
from vtk import vtkXMLUnstructuredGridReader
reader = vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_mesh = reader.GetOutput()
vertices, faces = _dump_vtk(vtk_mesh)
return Mesh(vertices, faces, name)
def readVTK(a_FileName, a_Legacy='none'):
if a_FileName.endswith('.vtu'):
reader = vtk.vtkXMLUnstructuredGridReader()
elif a_FileName.endswith('.vtp'):
reader = vtk.vtkXMLPolyDataReader()
elif a_FileName.endswith('.vtk'):
if a_Legacy == 'none':
print("Need To Specify Data Type For Legacy Files")
sys.exit()
elif a_Legacy == 'vtu':
reader = vtk.vtkUnstructuredGridReader()
elif a_Legacy == 'vtp':
reader = vtk.vtkPolyDataReader()
else:
print("Unsupported File Extension")
sys.exit()
#print("Reading From File", a_FileName)
reader.SetFileName(a_FileName)
reader.Update()
data = reader.GetOutput()
return data
def read_mesh(self, file_name):
print("[Volume.read_mesh] file_name: " + file_name)
file_base_name, ext = os.path.splitext(file_name)
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update()
return reader.GetOutput()
def load_points_from_file(filename):
""" Extract vtk mesh from input file.
:returns: Vtk mesh. """
if not os.path.exists(filename):
raise ValueError(f'File {filename} does not exist')
fileType = filename[-4:].lower()
if fileType == ".stl":
reader = vtk.vtkSTLReader()
elif fileType == ".obj":
reader = vtk.vtkOBJReader()
elif fileType == ".vtk":
reader = vtk.vtkPolyDataReader()
elif fileType == ".vtu":
reader = vtk.vtkXMLUnstructuredGridReader()
elif fileType == ".vtp":
reader = vtk.vtkXMLPolyDataReader()
else:
raise IOError(
"Mesh should be .vtk, .vtu, .vtp, .obj, .stl file!")
reader.SetFileName(filename)
reader.Update()
mesh = reader.GetOutput()
return mesh
def _test(self, fname):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(VTK_DATA_ROOT + fname)
elev = vtk.vtkElevationFilter()
elev.SetInputConnection(reader.GetOutputPort())
elev.SetLowPoint(-0.05, 0.05, 0)
elev.SetHighPoint(0.05, 0.05, 0)
grad = vtk.vtkGradientFilter()
grad.SetInputConnection(elev.GetOutputPort())
grad.SetInputArrayToProcess(0, 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS, "Elevation")
grad.Update()
vals = (10, 0, 0)
for i in range(3):
r = grad.GetOutput().GetPointData().GetArray("Gradients").GetRange(i)
self.assertTrue(abs(r[0] - vals[i]) < 1E-4)
self.assertTrue(abs(r[1] - vals[i]) < 1E-4)
elev.SetLowPoint(0.05, -0.05, 0)
elev.SetHighPoint(0.05, 0.05, 0)
grad.Update()
vals = (0, 10, 0)
for i in range(3):
r = grad.GetOutput().GetPointData().GetArray("Gradients").GetRange(i)
self.assertTrue(abs(r[0] - vals[i]) < 1E-4)
self.assertTrue(abs(r[1] - vals[i]) < 1E-4)
def ReadMesh(filename):
reader = vtk.vtkXMLPolyDataReader() if filename.endswith(
'vtp') else vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
polyDataModel = reader.GetOutput()
# Set the nodes and coordinates.
nNodes = polyDataModel.GetNumberOfPoints() # _nNodes
nodes = np.copy(vtk_to_numpy(
polyDataModel.GetPoints().GetData())) # _nodes
nodes = nodes.astype(float)
# Set the element groups, will be updated to sub-group after partition.
nElements = polyDataModel.GetNumberOfCells()
elementNodeIds = np.empty((nElements, 4),
dtype=int) # 4 nodes for tetrohedron
for iElm in range(nElements):
vtkCell = polyDataModel.GetCell(iElm)
for iNode in range(4):
elementNodeIds[iElm, iNode] = vtkCell.GetPointId(iNode)
return nodes, elementNodeIds
def __init__(self, fluidFile, vName, pName):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(fluidFile)
reader.Update()
polyDataModel = reader.GetOutput()
self.nNodes = polyDataModel.GetNumberOfPoints() # _nNodes
self.nodes = np.copy(vtk_to_numpy(
polyDataModel.GetPoints().GetData())) # _nodes
self.nodes = self.nodes.astype(float)
self.glbNodeIds = vtk_to_numpy(
polyDataModel.GetPointData().GetArray('GlobalNodeID'))
self.glbElementIds = vtk_to_numpy(
polyDataModel.GetCellData().GetArray('GlobalElementID'))
# Set the element groups, will be updated to sub-group after partition.
self.nElements = polyDataModel.GetNumberOfCells()
elements = np.empty((self.nElements, 4), dtype=np.int64)
for iElm in range(self.nElements):
vtkCell = polyDataModel.GetCell(iElm)
elements[iElm] = np.array(
[vtkCell.GetPointId(ipt) for ipt in range(4)])
# Pullout the nodes of each element to construct element's nodes matrix.
self.elementNodeIds = elements
# Read the velocity and pressure result.
self.du = vtk_to_numpy(polyDataModel.GetPointData().GetArray(vName))
self.p = vtk_to_numpy(polyDataModel.GetPointData().GetArray(pName))
def __init__(self, outDir):
self.outDir = outDir
self.fileList, self.parentFile = self.getfileList()
self.part_vars = ['coords']
self.vtkReader = vtk.vtkXMLUnstructuredGridReader()
self.nvars = self.getNumberOfVars()
self.availableVtuVars = self.getAvailableVars()
def create_from_vtk_file(cls, file_name='tests.vtk', in_xml_format=True):
"""
Factory method: create checker from a given VTK mesh file
:param file_name:
:param in_xml_format:
:return:
"""
print('--> Reading file \'{}\'...'.format(file_name))
reader = vtk.vtkXMLUnstructuredGridReader(
) if in_xml_format else vtk.vtkUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update()
op = reader.GetOutput()
vtk_mesh = vtk.vtkUnstructuredGrid()
vtk_mesh.SetPoints(op.GetPoints())
# add the elements
for ele_idx in range(op.GetNumberOfCells()):
vtk_ele = op.GetCell(ele_idx)
vtk_mesh.InsertNextCell(vtk_ele.GetCellType(),
vtk_ele.GetPointIds())
return VTKMeshChecker(vtk_mesh)
def get_pointdata(offset,filenameout='data',type='pvtu',attribute_mode='cell'):
if type == 'vtu':
filename=''.join([filenameout,repr(offset).zfill(4),'.vtu'])
datareader = v.vtkXMLUnstructuredGridReader()
elif type == 'pvtu':
filename=''.join([filenameout,repr(offset).zfill(4),'.pvtu'])
datareader = v.vtkXMLPUnstructuredGridReader()
print '=== Reading ',filename,' ==='
datareader.SetFileName(filename)
datareader.Update()
data = datareader.GetOutput()
if attribute_mode == 'cell':
c2p = v.vtkCellDataToPointData()
c2p.SetInput(data)
pointdata=c2p.GetOutput()
pointdata.Update()
else:
pointdata = data
vtk_points=data.GetPoints().GetData()
points=ah.vtk2array(vtk_points)
print '=== Done with reading data! ==='
return {'pointdata': pointdata, 'points': points}
def load_vtk(filepath):
file_extension = osp.splitext(filepath)[1]
if file_extension == '.vtu':
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filepath)
reader.Update()
grid = reader.GetOutput()
return grid
elif file_extension == '.vtk':
reader = vtk.vtkDataSetReader()
reader.SetFileName(filepath)
reader.Update()
if reader.GetUnstructuredGridOutput() is not None:
return reader.GetUnstructuredGridOutput()
elif reader.GetPolyDataOutput() is not None:
return reader.GetPolyDataOutput()
elif reader.GetStructuredPointsOutput() is not None:
raise RuntimeError('StructuredPoints not supported (yet?)')
elif reader.GetStructuredGridOutput() is not None:
filtered = append_filter(reader.GetStructuredGridOutput())
return filtered
elif reader.GetRectilinearGridOutput() is not None:
raise RuntimeError('RectilinearGrid not supported (yet?)')
else:
raise RuntimeError('Unrecognized data type')
else:
raise RuntimeError('Unknown file type {}'.format(file_extension))
def save_lesion(output_file, input_file, field, limits):
reader = v.vtkXMLUnstructuredGridReader()
reader.SetFileName(input_file)
reader.Update()
threshold = v.vtkThreshold()
threshold.SetInput(reader.GetOutput())
if limits[0] is None:
threshold.ThresholdByLower(limits[1])
elif limits[1] is None:
threshold.ThresholdByUpper(limits[0])
else:
threshold.ThresholdBetween(*limits)
threshold.SetInputArrayToProcess(0, 0, 0, v.vtkDataObject.FIELD_ASSOCIATION_CELLS, field)
threshold.Update()
extract_surface = v.vtkDataSetSurfaceFilter()
extract_surface.SetInput(threshold.GetOutput())
extract_surface.Update()
writer = v.vtkXMLPolyDataWriter()
writer.SetFileName(output_file)
writer.SetInput(extract_surface.GetOutput())
writer.Write()
def DoLineSampling(file_path, domain, pc):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(file_path)
reader.Update()
sample_spacing = 60.0
height = pc.get_parameter("PelletHeight").value
height = height.Convert(1.0e-6 * metres)
radius = pc.get_parameter("CorneaRadius").value
radius = radius.Convert(1.0e-6 * metres)
width = 2.0 * np.pi * radius
num_samples = int(height / sample_spacing)
points = vtk.vtkPoints()
for idx in range(num_samples):
points.InsertNextPoint(width / 2.0, float(idx * sample_spacing), 0.0)
poly = vtk.vtkPolyData()
poly.SetPoints(points)
probe = vtk.vtkProbeFilter()
probe.SetSourceData(reader.GetOutput())
probe.SetInputData(poly)
probe.Update()
results = probe.GetOutput().GetPointData().GetArray("Line Density")
for idx in range(results.GetNumberOfTuples()):
print "y", points.GetPoint(idx)[1], " rho ", results.GetTuple1(idx)
def check_min_max_radii():
# Loop over vtu's and check that each core does not extend from inner radius to outer radius:
filelist = glob.glob("Stokes_sphere_0/Stokes_sphere_0_*.vtu")
filelist.sort()
smallest_radius_max = constants.outer_radius
largest_radius_min = constants.inner_radius
for filename in filelist:
print('Working on file:', filename)
# Set up reader (note that vtktools does this automatically, but vtktools isn't being used here):
if filename[-4:] == ".vtu":
reader=vtk.vtkXMLUnstructuredGridReader()
else:
raise Exception("ERROR: don't recognise file extension" + filename)
reader.SetFileName(filename)
reader.Update()
# Extract and store all field data:
data = reader.GetOutput()
# Extract radius information:
radius_data = data.GetPointData().GetScalars("Radius")
# Convert radii into a nice numpy array:
radius = numpy.array([radius_data.GetValue(p) for p in xrange(radius_data.GetNumberOfTuples())])
# Check for smallest maximum radius and largest minimum radius on each core:
smallest_radius_max = min(smallest_radius_max, numpy.max(radius))
largest_radius_min = max(largest_radius_min, numpy.min(radius))
return smallest_radius_max, largest_radius_min
def GetDensityMetrics(file_path, domain, pc):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(file_path)
reader.Update()
grid = reader.GetOutput()
line_density = grid.GetCellData().GetArray("Line Density")
line_density_volume = 0.0
total_volume = 0.0
offset = pc.get_parameter("LimbalOffset").value
offset = offset.Convert(1.0e-6 * metres)
height = pc.get_parameter("PelletHeight").value
height = height.Convert(1.0e-6 * metres)
for idx in range(grid.GetNumberOfCells()):
points = grid.GetCell(idx).GetPoints()
loc = np.zeros(3)
for jdx in range(points.GetNumberOfPoints()):
if jdx == 0:
loc = np.array(points.GetPoint(jdx))
else:
loc += np.array(points.GetPoint(jdx))
loc /= float(points.GetNumberOfPoints())
cell_volume = abs(vtk.vtkMeshQuality.HexVolume(grid.GetCell(idx)))
total_volume += cell_volume
cell_line_density = line_density.GetTuple1(idx)
if cell_line_density >= 1.e-9:
line_density_volume += cell_volume
line_fraction = line_density_volume / total_volume
return [line_fraction, 1.0]
def _load_file(self, filename):
"""Load an unstructured grid from a file.
The file extension will select the type of reader to use. A .vtk
extension will use the legacy reader, while .vtu will select the VTK
XML reader.
Parameters
----------
filename : str
Filename of grid to be loaded.
"""
filename = os.path.abspath(os.path.expanduser(filename))
# check file exists
if not os.path.isfile(filename):
raise Exception('%s does not exist' % filename)
# Check file extension
if '.vtu' in filename:
reader = vtk.vtkXMLUnstructuredGridReader()
elif '.vtk' in filename:
reader = vtk.vtkUnstructuredGridReader()
else:
raise Exception('Extension should be either ".vtu" or ".vtk"')
# load file to self
reader.SetFileName(filename)
reader.Update()
grid = reader.GetOutput()
self.shallow_copy(grid)
def convert_vtk_file(vtk_file, plt_file, strand=None, solution_time=None):
reader = None
if vtk_file.endswith(".vtu"):
reader = vtk.vtkXMLUnstructuredGridReader()
elif vtk_file.endswith(".vtp"):
reader = vtk.vtkXMLPolyDataReader()
elif vtk_file.endswith(".vts"):
reader = vtk.vtkXMLStructuredGridReader()
elif vtk_file.endswith(".vti"):
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(vtk_file)
reader.Update()
vtk_dataset = reader.GetOutput()
tp.new_layout()
tecplot_dataset = tp.active_frame().dataset
add_vtk_dataset(vtk_dataset, tecplot_dataset)
if tecplot_dataset.num_zones == 0:
print("No zones created.")
return
for z in tecplot_dataset.zones():
z.name = os.path.basename(vtk_file)
if strand and solution_time:
z.strand = strand
z.solution_time = solution_time
tp.data.save_tecplot_plt(plt_file, dataset=tecplot_dataset)
def createCellLocator(a_FileName, a_LocatorType=None, a_Legacy='vtp'):
if a_FileName.endswith('vtu'):
reader = vtk.vtkXMLUnstructuredGridReader()
elif a_FileName.endswith('vtp'):
reader = vtk.vtkXMLPolyDataReader()
elif a_FileName.endswith('.vtk'):
if a_Legacy == 'none':
print("Need To Specify Data Type For Legacy Files")
sys.exit()
elif a_Legacy == 'vtu':
reader = vtk.vtkUnstructuredGridReader()
elif a_Legacy == 'vtp':
reader = vtk.vtkPolyDataReader()
else:
print("Unsupported File Extension")
sys.exit()
reader.SetFileName(a_FileName)
reader.Update()
if a_LocatorType is None:
locator = vtk.vtkCellTreeLocator()
else:
if a_LocatorType == 'oct':
locator = vtk.vtkCellLocator()
elif a_LocatorType == 'tre':
locator = vtk.vtkCellTreeLocator()
elif a_LocatorType == 'bsp':
locator = vtk.vtkModifiedBSPTree()
locator.SetDataSet(reader.GetOutput())
locator.BuildLocator()
return locator
def __init__(self, filename=None):
"""Creates a vtu object by reading the specified file."""
if filename is None:
self.ugrid = vtk.vtkUnstructuredGrid()
else:
self.gridreader = None
if filename[-4:] == ".vtu":
self.gridreader = vtk.vtkXMLUnstructuredGridReader()
elif filename[-5:] == ".pvtu":
self.gridreader = vtk.vtkXMLPUnstructuredGridReader()
else:
raise Exception("ERROR: don't recognise file extension" +
filename)
self.gridreader.SetFileName(filename)
self.gridreader.Update()
self.ugrid = self.gridreader.GetOutput()
self.points = self.ugrid.GetPoints()
self.pointdata = self.ugrid.GetPointData()
self.cells = self.ugrid.GetCells()
self.celldata = self.ugrid.GetCellData()
if self.ugrid.GetNumberOfPoints() + self.ugrid.GetNumberOfCells(
) == 0:
raise Exception(
"ERROR: No points or cells found after loading vtu " +
filename)
self._coords = None
self.filename = filename
self._data_dict = {}
self._rawdata_dict = {}
self._rawcelldata_dict = {}
self._raw_coords = None
def read_from_xml(file_path, fidelity):
"""Read VTU file"""
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(file_path)
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
# Saving into Numpy arrays
# print(output.GetPointData())
displacement = Mesh(
MeshType.DISPLACEMENT,
vtk_to_numpy(output.GetPointData().GetArray("displacement")))
try:
strain = Mesh(
MeshType.STRAIN,
vtk_to_numpy(
output.GetPointData().GetArray("nodal_EA_strains_xyz")))
except:
strain_a = vtk_to_numpy(
output.GetPointData().GetArray("nodal_EA_strains_eigenval1"))
strain_b = vtk_to_numpy(
output.GetPointData().GetArray("nodal_EA_strains_eigenval2"))
strain_c = vtk_to_numpy(
output.GetPointData().GetArray("nodal_EA_strains_eigenval3"))
strain_a = np.reshape(strain_a, (np.shape(strain_a)[0], 1))
strain_b = np.reshape(strain_b, (np.shape(strain_b)[0], 1))
strain_c = np.reshape(strain_c, (np.shape(strain_c)[0], 1))
strain = np.concatenate((strain_a, strain_b, strain_c), axis=1)
strain = Mesh(MeshType.STRAIN, strain)
van_mises = Mesh(
MeshType.VAN_MISES,
vtk_to_numpy(
output.GetPointData().GetArray("nodal_cauchy_stresses_xyz")))
return Xml(fidelity, van_mises, displacement, strain)
def main():
# try:
parser = argparse.ArgumentParser()
parser.add_argument(
"invtkfile",
help="filename of input vtk mesh (VTK XML unstructured grid")
parser.add_argument("varname", help="name of cell data variable")
parser.add_argument(
"outvtkfile",
help="filename of output vtk mesh (VTK XML unstructured grid")
args = parser.parse_args()
# deserialize raw bytes into VarDataAdd
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(args.invtkfile)
reader.Update()
mesh = reader.GetOutput()
assert isinstance(mesh, vtk.vtkUnstructuredGrid)
numcells = mesh.GetCells().GetSize()
# write 0..N-1 into data
npdata = np.arange(0, numcells, 0.1)
writeDataArrayToNewVtkFile(args.invtkfile, args.varname, npdata,
args.outvtkfile)
print("done")
def setUp(self):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName('gradient_coarse.vtu')
reader.Update()
self.nodes = np.empty((reader.GetOutput().GetNumberOfPoints(), 3))
for n in range(reader.GetOutput().GetNumberOfPoints()):
x = reader.GetOutput().GetPoint(n)
self.nodes[n, 0] = x[0]
self.nodes[n, 1] = x[1]
self.nodes[n, 2] = x[2]
self.tet = np.empty((reader.GetOutput().GetNumberOfCells(), 4),
dtype=int)
ind = vtk.vtkIdList()
for n in range(reader.GetOutput().GetNumberOfCells()):
reader.GetOutput().GetCellPoints(n, ind)
self.tet[n, 0] = ind.GetId(0)
self.tet[n, 1] = ind.GetId(1)
self.tet[n, 2] = ind.GetId(2)
self.tet[n, 3] = ind.GetId(3)
data = reader.GetOutput()
self.slowness = vtk_to_numpy(data.GetPointData().GetArray('Slowness'))
self.src = np.loadtxt('src.dat', skiprows=1)
self.src = self.src.reshape((1, 4))
self.rcv = np.loadtxt('rcv.dat', skiprows=1)
def create_probe(filename):
if(verbose):
print "Creating probe from ", filename
pd = vtk.vtkStructuredPoints()
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
ugrid = reader.GetOutput()
ugrid.Update()
b = ugrid.GetBounds()
pd.SetOrigin(b[0], b[2], b[4])
l = [b[1] - b[0], b[3] - b[2], b[5] - b[4]]
tot_len = float(l[0] + l[1] + l[2])
dims = intervals
pd.SetExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1)
pd.SetUpdateExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1)
pd.SetWholeExtent(0, dims[0]-1, 0, dims[1] -1, 0, dims[2] -1)
pd.SetDimensions(dims)
dims = [max(1, x-1) for x in dims]
l = [max(1e-3, x) for x in l]
sp = [l[0]/dims[0], l[1]/dims[1], l[2]/dims[2]]
pd.SetSpacing(sp)
return pd
def setCondition(self, value, fieldname, n=None, dof=None, valueDof=None):
""" Setting the initial conditions of the mesh based on the configuration,
if it's presetting uniform value then set it to the whole geometry
otherwise read it from geometry (vtp) files.
"""
if isinstance(value, str):
reader = vtk.vtkXMLPolyDataReader() if value.endswith(
'vtp') else vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(value)
reader.Update()
polyDataModel = reader.GetOutput()
# TODO:: check the compatibility between initial condition file and the mesh's geometry
prop = vtk_to_numpy(
polyDataModel.GetPointData().GetArray(fieldname))
else:
if n is None:
n = self.nNodes
if dof is None:
dof = self.dof
prop = np.zeros((n, dof))
if valueDof is None:
prop[:, :] = value
else:
prop[:, valueDof] = value
prop = prop.ravel()
return prop
def __init__(self,
filename,
nneighbors=20,
dim=3,
one_d_axis=0,
two_d_planenormal=2,
interpolation_backend="scipy"):
self.filename = filename
self.reader = vtk.vtkXMLUnstructuredGridReader()
self.reader.SetFileName(self.filename)
self.reader.Update()
self.output = self.reader.GetOutput()
self.pdata = self.output.GetPointData()
self.cdata = self.output.GetCellData()
self.points = vtk_to_numpy(self.output.GetPoints().GetData())
self._cell_center_points = None
self.dim = dim
self.nneighbors = nneighbors
self.one_d_axis = one_d_axis
self.two_d_planenormal = two_d_planenormal
if self.dim == 1:
self.one_d_axis = one_d_axis
self.points = self.points[:, one_d_axis]
if self.dim == 2:
self.plane = [0, 1, 2]
self.plane.pop(two_d_planenormal)
self.points = np.delete(self.points, two_d_planenormal, 1)
self.interpolation_backend = interpolation_backend
def read(filenames, timestep=None):
'''Reads an unstructured mesh with added data.
:param filenames: The files to read from.
:type filenames: str
:param timestep: Time step to read from, in case of an Exodus input mesh.
:type timestep: int, optional
:returns mesh{2,3}d: The mesh data.
:returns point_data: Point data read from file.
:type point_data: dict
:returns field_data: Field data read from file.
:type field_data: dict
'''
if isinstance(filenames, (list, tuple)) and len(filenames)==1:
filenames = filenames[0]
if isinstance(filenames, basestring):
filename = filenames
# serial files
extension = os.path.splitext(filename)[1]
import re
# setup the reader
# TODO Most readers have CanReadFile() -- use that.
if extension == '.vtu':
from vtk import vtkXMLUnstructuredGridReader
reader = vtkXMLUnstructuredGridReader()
vtk_mesh = _read_vtk_mesh(reader, filename)
elif extension == '.vtk':
from vtk import vtkUnstructuredGridReader
reader = vtkUnstructuredGridReader()
vtk_mesh = _read_vtk_mesh(reader, filename)
elif extension == '.xmf':
from vtk import vtkXdmfReader
reader = vtkXdmfReader()
vtk_mesh = _read_vtk_mesh(reader, filename)
elif extension in [ '.ex2', '.exo', '.e' ]:
from vtk import vtkExodusIIReader
reader = vtkExodusIIReader()
reader.SetFileName( filename )
vtk_mesh = _read_exodusii_mesh(reader, timestep=timestep)
elif re.match('[^\.]*\.e\.\d+\.\d+', filename):
# Parallel Exodus files.
# TODO handle with vtkPExodusIIReader
from vtk import vtkExodusIIReader
reader = vtkExodusIIReader()
reader.SetFileName( filenames[0] )
vtk_mesh = _read_exodusii_mesh(reader, timestep=timestep)
else:
raise RuntimeError( 'Unknown file type \'%s\'.' % filename )
else:
# Parallel files.
# Assume Exodus format as we don't know anything else yet.
from vtk import vtkPExodusIIReader
# TODO Guess the file pattern or whatever.
reader = vtkPExodusIIReader()
reader.SetFileNames( filenames )
vtk_mesh = _read_exodusii_mesh(reader, filename, timestep=timestep)
return vtk_mesh
def ReadVTKXMLMeshFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading VTK XML mesh file.')
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Mesh = reader.GetOutput()
def test_clean_unstructured_grid():
""" Test the clean_unstructured_grid routine"""
reader = vtk.vtkXMLUnstructuredGridReader()
del reader
ugrid = vtk.vtkUnstructuredGrid()
clean_grid = IO.clean_unstructured_grid(ugrid)
assert clean_grid
def parseDump (filename):
reader=vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
output=reader.GetOutput()
celldata=output.GetCellData()
cells=output.GetCells()
points=output.GetPoints()
return cells,celldata,points
def __init__(self, filename, mesh=None, deepcopy=False):
"""
Initialize a the reader with a pvd or a vtu filename
"""
if not os.path.isfile(filename):
raise IOError("File '%s' does not excist"%filename)
filetype = filename.split(".")[-1]
self._name = ".".join(filename.split(".")[0:-1])
if filetype not in ["pvd", "vtu"]:
raise TypeError("Expected a 'pvd' or a 'vtu' file")
# Get dirname
dirname = os.path.dirname(filename)
# Check mesh argument
if mesh is not None and not isinstance(mesh, Mesh):
raise TypeError, "Expected a 'Mesh' for the mesh arguments"
# Store deepcopy argument
self._deepcopy = deepcopy
# Store mesh
self._mesh = mesh
# Initialize the filename cache
self._filenames = []
if filetype == "vtu":
self._filenames.append(filename)
self._times = np.array([])
else:
# Parse pvd file
tree = ElementTree(file=filename)
times = []
for item in tree.iter():
if item.tag == "DataSet":
self._filenames.append(os.path.join(\
dirname,item.attrib["file"]))
times.append(float(item.attrib["timestep"]))
times = np.array(times, dtype='d')
# If there are no time data stored in the file use an empty array
if np.all(np.diff(times)==1):
times = np.array([])
# Store time data
self._times = times
# Construct file reader
self.reader = vtk.vtkXMLUnstructuredGridReader()
# Read in data from file
self._update_vtk_data()
# Init dolfin structures (Function, FunctionSpace)
self._init_dolfin_data()
def vtu_points(offset,filenameout='data',):
filename=''.join([filenameout,repr(offset).zfill(4),'.vtu'])
datareader = v.vtkXMLUnstructuredGridReader()
datareader.SetFileName(filename)
datareader.Update()
data = datareader.GetOutput()
vtk_points=data.GetPoints().GetData()
points=ah.vtk2array(vtk_points)
return points
def open(self, k):
""" Open a file for reading."""
rdr = vtk.vtkXMLUnstructuredGridReader()
print 'loading %s'%self.data[k][1]
rdr.SetFileName(self.data[k][1])
rdr.Update()
self.data[k][2] = rdr.GetOutput()
cloc = vtk.vtkCellLocator()
cloc.SetDataSet(self.data[k][2])
cloc.BuildLocator()
self.data[k][3] = cloc
def vtu_values(offset,varname,filenameout='data',attribute_mode='cell',type='vtu'):
if type == 'vtu':
filename=''.join([filenameout,repr(offset).zfill(4),'.vtu'])
datareader = v.vtkXMLUnstructuredGridReader()
elif type == 'pvtu':
filename=''.join([filenameout,repr(offset).zfill(4),'.pvtu'])
datareader = v.vtkXMLPUnstructuredGridReader()
datareader.SetFileName(filename)
datareader.Update()
data = datareader.GetOutput()
return read.extract(data,varname,attribute_mode=attribute_mode)
def read_ugrid(filename):
if filename.endswith(".pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif filename.endswith(".vtk"):
reader = vtk.vtkUnstructuredGridReader()
elif filename.endswith(".vtu"):
reader = vtk.vtkXMLUnstructuredGridReader()
else:
raise BaseException("Illegal filename suffix %s" % filename)
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def fun(time):
"""Factory function to mock a temporal cache."""
del time
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(ldir+'/'+fname)
reader.Update()
locator = vtk.vtkCellLocator()
locator.SetDataSet(reader.GetOutput())
locator.BuildLocator()
return ([[0.0, fname, reader.GetOutput(), locator],
[1.0, fname, reader.GetOutput(), locator]], 0.0,
[['Velocity', 'Pressure'], ['Velocity', 'Pressure']])
def extract_data(self):
"""
Extract the data from the VTK file using the python-vtk library
The data is passed to numpy arrays for better manipulation
"""
# Check the type of file to load it according to its grid structure
# which was specified when calling the class These dictionary entries
# return the corresponding VTK Reader functions, so they can be easily
# called according to the class argument
reader_type = {
'XMLUnstructuredGrid': lambda: vtk.vtkXMLUnstructuredGridReader(),
'XMLStructuredGrid': lambda: vtk.vtkXMLStructuredGridReader(),
'UnstructuredGrid': lambda: vtk.vtkUnstructuredGridReader(),
'StructuredGrid': lambda: vtk.vtkStructuredGridReader(),
}
if self.vtkfiletype.startswith('XML'):
# Load the vtk file from the input file
self.reader = reader_type[self.vtkfiletype]()
self.reader.SetFileName(self.vtk_file)
else:
# Load the vtk file from the input file
self.reader = reader_type[self.vtkfiletype]()
self.reader.SetFileName(self.vtk_file)
# For Non XML vtk files:
self.reader.ReadAllVectorsOn()
self.reader.ReadAllScalarsOn()
self.reader.Update()
# Get the coordinates of the nodes in the mesh
nodes_vtk_array = self.reader.GetOutput().GetPoints().GetData()
# Get The vector field (data of every node)
vf_vtk_array = self.reader.GetOutput().GetPointData().GetArray(0)
# Transform the coordinates of the nodes to a Numpy array and
# save them to the corresponding class objects
nodes_numpy_array = vtk_to_numpy(nodes_vtk_array)
self.x, self.y, self.z = (nodes_numpy_array[:, 0],
nodes_numpy_array[:, 1],
nodes_numpy_array[:, 2]
)
# Transform the magnetisation data to a Numpy array and save
vf_numpy_array = vtk_to_numpy(vf_vtk_array)
self.vf = vf_numpy_array
def readData(self):
if self.type == 'vtu':
filename=''.join([self.filenameout,repr(self.offset).zfill(4),'.vtu'])
datareader = v.vtkXMLUnstructuredGridReader()
elif self.type == 'pvtu':
filename=''.join([self.filenameout,repr(self.offset).zfill(4),'.pvtu'])
datareader = v.vtkXMLPUnstructuredGridReader()
print '=== Reading ',filename,' ==='
datareader.SetFileName(filename)
datareader.Update()
self.data = datareader.GetOutput()
vtk_points=self.data.GetPoints().GetData()
self.points=ah.vtk2array(vtk_points)
def Test2(datadir):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(datadir + "/Data/elements.vtu")
reader.UpdateInformation();
reader.GetPointDataArraySelection().EnableAllArrays()
reader.GetCellDataArraySelection().EnableAllArrays()
f = vtk.vtkIntegrateAttributes()
f.SetInputConnection(reader.GetOutputPort())
f.Update()
result = f.GetOutputDataObject(0)
val = result.GetPointData().GetArray("pointScalars").GetValue(0)
assert (val > 83.1 and val < 83.2)
val = result.GetCellData().GetArray("Volume").GetValue(0)
assert (val > 1.999 and val < 2.01)
def Test1(datadir):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(datadir + "/Data/quadraticTetra01.vtu")
reader.UpdateInformation();
reader.GetPointDataArraySelection().EnableAllArrays()
reader.GetCellDataArraySelection().EnableAllArrays()
f = vtk.vtkIntegrateAttributes()
f.SetInputConnection(reader.GetOutputPort())
f.Update()
result = f.GetOutputDataObject(0)
val = result.GetPointData().GetArray("scalars").GetValue(0)
assert (val > 0.0162 and val < 0.01621)
val = result.GetCellData().GetArray("Volume").GetValue(0)
assert (val > 0.128 and val < 0.1284)
def Save_VTK_data_to_picture_file(inputFileName, field_name,
node_or_cell, outputFileName
):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(inputFileName)
reader.Update()
if node_or_cell== 'CELLS':
reader.CellArrayStatus = [field_name]
reader.GetOutput().GetCellData().SetActiveScalars(field_name)
elif node_or_cell== 'NODES':
reader.PointArrayStatus = [field_name]
reader.GetOutput().GetPointData().SetActiveScalars(field_name)
else:
raise ValueError("unknown type : should be CELLS or NODES")
#-------------------------------------------------------------------------------
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(reader.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
scalarBar=vtk.vtkScalarBarActor()
scalarBar.SetLookupTable(mapper.GetLookupTable())
scalarBar.SetTitle(field_name)
mapper.SetScalarRange(reader.GetOutput().GetScalarRange())
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
ren.AddViewProp(actor)
ren.AddActor2D(scalarBar);
renWin.Render()
image = vtk.vtkWindowToImageFilter()
image.SetInput(renWin)
image.ReadFrontBufferOff()
image.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(outputFileName+".png")
writer.SetInputConnection(image.GetOutputPort())
writer.Write()
def probe(pd, filename):
if(verbose):
print "Opening ", filename
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(filename)
ugrid = reader.GetOutput()
ugrid.Update()
if(verbose):
print "Probing"
probe = vtk.vtkProbeFilter()
probe.SetSource(ugrid)
probe.SetInput(pd)
probe.Update()
return probe.GetOutput()
def __init__(self, filename = None):
"""Creates a vtu object by reading the specified file."""
if filename is None:
self.ugrid = vtk.vtkUnstructuredGrid()
else:
self.gridreader = None
if filename[-4:] == ".vtu":
self.gridreader=vtk.vtkXMLUnstructuredGridReader()
elif filename[-5:] == ".pvtu":
self.gridreader=vtk.vtkXMLPUnstructuredGridReader()
else:
raise Exception("ERROR: don't recognise file extension" + filename)
self.gridreader.SetFileName(filename)
self.gridreader.Update()
self.ugrid=self.gridreader.GetOutput()
if self.ugrid.GetNumberOfPoints() + self.ugrid.GetNumberOfCells() == 0:
raise Exception("ERROR: No points or cells found after loading vtu " + filename)
self.filename=filename
