def read_vtr(fname):
reader = vtk.vtkXMLPRectilinearGridReader()
reader.SetFileName(fname)
reader.Update()
data = reader.GetOutput()
pointData = data.GetPointData()
sh = data.GetDimensions()[::-1]
ndims = len(sh)
# get vector field
v = np.array(pointData.GetVectors("Velocity")).reshape(sh + (ndims, ))
vec = []
for d in range(ndims):
a = v[..., d]
vec.append(a)
vec = np.array(vec)
# get scalar field
sca = np.array(pointData.GetScalars('Pressure')).reshape(sh + (1, ))
# get grid
x = np.array(data.GetXCoordinates())
y = np.array(data.GetYCoordinates())
z = np.array(data.GetZCoordinates())
return np.transpose(vec, (0, 3, 2, 1)), np.transpose(
sca, (0, 3, 2, 1)), np.array([x, y, z])
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkXMLPRectilinearGridReader(), 'Reading vtkXMLPRectilinearGrid.',
(), ('vtkXMLPRectilinearGrid',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkXMLPRectilinearGridReader(),
'Reading vtkXMLPRectilinearGrid.',
(), ('vtkXMLPRectilinearGrid', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def test_prectilinear_grid_mpi(compression_fixture, format_fixture):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
N = 3
bounds = [(0, 1), (1, 2)]
offsets = [
[0, 0, 0],
[2 * N, 0, 0],
]
x = np.linspace(*bounds[rank], N * 2)
y = np.linspace(0, 1, N + 2)
z = np.linspace(0, 1, N)
out_name = 'test_prectilinear_grid_mpi.pvtr'
xx, yy, zz = np.meshgrid(x, y, z, indexing='ij', sparse=True)
r = np.sqrt(xx**2 + yy**2 + zz**2)
compress = compression_fixture.param
format = format_fixture.param
rect = PRectilinearGrid(out_name, (x, y, z),
offsets[rank],
compression=compress)
rect.addPointData(DataArray(r, range(3), 'R'), vtk_format=format)
rect.write()
if rank == 0:
reader = vtk.vtkXMLPRectilinearGridReader()
reader.SetFileName(out_name)
reader.Update()
output = reader.GetOutput()
vtk_r = vtk_to_numpy(output.GetPointData().GetArray('R'))
else:
vtk_r = None
vtk_r = comm.bcast(vtk_r, root=0)
vtk_r = vtk_r.reshape([4 * N - 1, N + 2, N], order='F')
i, j, k = [int(i) for i in offsets[rank]]
# Adjusting for overlap
if offsets[rank][0] != 0:
i -= 1
sub_vtk = vtk_r[i:i + x.size, j:j + y.size, k:k + z.size]
assert np.all(sub_vtk == r)
clean(rect)
def test_prectilinear_grid(field_data, compression_fixture, format_fixture,
ordering_fixture):
coords, r, e_r, field, order = field_data
dim = r.ndim
out_name = 'test_prectilinear_grid.pvtr'
compress = compression_fixture.param
format = format_fixture.param
rect = PRectilinearGrid(out_name,
coords,
dim * [0],
compression=compress,
byte_order=order)
rect.init_master(None) # useless here: for coverage only
rect.addPointData(
DataArray(r,
range(dim),
'point',
components_order=ordering_fixture.param),
vtk_format=format,
).addCellData(
DataArray(e_r,
range(dim),
'cell',
components_order=ordering_fixture.param),
vtk_format=format,
).addFieldData(
DataArray(field, [0], 'field',
components_order=ordering_fixture.param),
vtk_format=format,
).write()
reader = vtkXMLPRectilinearGridReader()
vtk_r, vtk_e_r, vtk_f = get_vtk_data(reader, out_name)
vtk_r = vtk_r.reshape(r.shape, order='F')
vtk_e_r = vtk_e_r.reshape(e_r.shape, order='F') \
.transpose(ordering_fixture.transp(dim))
assert all(vtk_r == r)
assert all(vtk_e_r == e_r)
assert all(vtk_f == field)
clean(rect)
print(da2.GetValue(0))
import os
os.remove(filename)
for i in range(npieces):
if not useSubdir:
os.remove(VTK_TEMP_DIR + "/%s_%d.%s" % (dataType, i, ext))
else:
os.remove(VTK_TEMP_DIR + "/%s/%s_%d.%s" %
(dataType, dataType, i, ext))
assert da2.GetValue(0) == numTris
TestDataType('ImageData', vtk.vtkXMLPImageDataReader(),
vtk.vtkXMLPImageDataWriter(), 'vti', 4924)
TestDataType('RectilinearGrid', vtk.vtkXMLPRectilinearGridReader(),
vtk.vtkXMLPRectilinearGridWriter(), 'vtr', 4924)
TestDataType('StructuredGrid', vtk.vtkXMLPStructuredGridReader(),
vtk.vtkXMLPStructuredGridWriter(), 'vts', 4924)
TestDataType('UnstructuredGrid', vtk.vtkXMLPUnstructuredGridReader(),
vtk.vtkXMLPUnstructuredGridWriter(), 'vtu', 11856)
# Test writers with UseSubdirectory on
TestDataType('ImageData',
vtk.vtkXMLPImageDataReader(),
vtk.vtkXMLPImageDataWriter(),
'vti',
4924,
useSubdir=True)
TestDataType('RectilinearGrid',
vtk.vtkXMLPRectilinearGridReader(),
def _load_file(filename, c, alpha, threshold, spacing, unpack):
fl = filename.lower()
################################################################# other formats:
if fl.endswith(".xml") or fl.endswith(".xml.gz") or fl.endswith(".xdmf"):
# Fenics tetrahedral file
actor = loadDolfin(filename)
elif fl.endswith(".neutral") or fl.endswith(".neu"): # neutral tetrahedral file
actor = loadNeutral(filename)
elif fl.endswith(".gmsh"): # gmesh file
actor = loadGmesh(filename)
elif fl.endswith(".pcd"): # PCL point-cloud format
actor = loadPCD(filename)
actor.GetProperty().SetPointSize(2)
elif fl.endswith(".off"):
actor = loadOFF(filename)
elif fl.endswith(".3ds"): # 3ds format
actor = load3DS(filename)
elif fl.endswith(".wrl"):
importer = vtk.vtkVRMLImporter()
importer.SetFileName(filename)
importer.Read()
importer.Update()
actors = importer.GetRenderer().GetActors() #vtkActorCollection
actors.InitTraversal()
wacts = []
for i in range(actors.GetNumberOfItems()):
act = actors.GetNextActor()
wacts.append(act)
actor = Assembly(wacts)
################################################################# volumetric:
elif fl.endswith(".tif") or fl.endswith(".slc") or fl.endswith(".vti") \
or fl.endswith(".mhd") or fl.endswith(".nrrd") or fl.endswith(".nii") \
or fl.endswith(".dem"):
img = loadImageData(filename, spacing)
if threshold is False:
if c is None and alpha == 1:
c = ['b','lb','lg','y','r'] # good for blackboard background
alpha = (0.0, 0.0, 0.2, 0.4, 0.8, 1)
actor = Volume(img, c, alpha)
else:
actor = Volume(img).isosurface(threshold=threshold)
actor.color(c).alpha(alpha)
################################################################# 2D images:
elif fl.endswith(".png") or fl.endswith(".jpg") or fl.endswith(".bmp") or fl.endswith(".jpeg"):
if ".png" in fl:
picr = vtk.vtkPNGReader()
elif ".jpg" in fl or ".jpeg" in fl:
picr = vtk.vtkJPEGReader()
elif ".bmp" in fl:
picr = vtk.vtkBMPReader()
picr.SetFileName(filename)
picr.Update()
actor = Picture() # object derived from vtk.vtkImageActor()
actor.SetInputData(picr.GetOutput())
if alpha is None:
alpha = 1
actor.SetOpacity(alpha)
################################################################# multiblock:
elif fl.endswith(".vtm") or fl.endswith(".vtmb"):
read = vtk.vtkXMLMultiBlockDataReader()
read.SetFileName(filename)
read.Update()
mb = read.GetOutput()
if unpack:
acts = []
for i in range(mb.GetNumberOfBlocks()):
b = mb.GetBlock(i)
if isinstance(b, (vtk.vtkPolyData,
vtk.vtkImageData,
vtk.vtkUnstructuredGrid,
vtk.vtkStructuredGrid,
vtk.vtkRectilinearGrid)):
acts.append(b)
return acts
else:
return mb
################################################################# numpy:
elif fl.endswith(".npy"):
acts = loadNumpy(filename)
if unpack == False:
return Assembly(acts)
return acts
elif fl.endswith(".geojson") or fl.endswith(".geojson.gz"):
return loadGeoJSON(fl)
################################################################# polygonal mesh:
else:
if fl.endswith(".vtk"): # read all legacy vtk types
#output can be:
# PolyData, StructuredGrid, StructuredPoints, UnstructuredGrid, RectilinearGrid
reader = vtk.vtkDataSetReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.ReadAllTensorsOn()
reader.ReadAllFieldsOn()
reader.ReadAllNormalsOn()
reader.ReadAllColorScalarsOn()
elif fl.endswith(".ply"):
reader = vtk.vtkPLYReader()
elif fl.endswith(".obj"):
reader = vtk.vtkOBJReader()
elif fl.endswith(".stl"):
reader = vtk.vtkSTLReader()
elif fl.endswith(".byu") or fl.endswith(".g"):
reader = vtk.vtkBYUReader()
elif fl.endswith(".foam"): # OpenFoam
reader = vtk.vtkOpenFOAMReader()
elif fl.endswith(".pvd"):
reader = vtk.vtkXMLGenericDataObjectReader()
elif fl.endswith(".vtp"):
reader = vtk.vtkXMLPolyDataReader()
elif fl.endswith(".vts"):
reader = vtk.vtkXMLStructuredGridReader()
elif fl.endswith(".vtu"):
reader = vtk.vtkXMLUnstructuredGridReader()
elif fl.endswith(".vtr"):
reader = vtk.vtkXMLRectilinearGridReader()
elif fl.endswith(".pvtk"):
reader = vtk.vtkPDataSetReader()
elif fl.endswith(".pvtr"):
reader = vtk.vtkXMLPRectilinearGridReader()
elif fl.endswith("pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif fl.endswith(".txt") or fl.endswith(".xyz"):
reader = vtk.vtkParticleReader() # (format is x, y, z, scalar)
elif fl.endswith(".facet"):
reader = vtk.vtkFacetReader()
else:
return None
reader.SetFileName(filename)
reader.Update()
routput = reader.GetOutput()
if not routput:
colors.printc("~noentry Unable to load", filename, c=1)
return None
actor = Actor(routput, c, alpha)
if fl.endswith(".txt") or fl.endswith(".xyz"):
actor.GetProperty().SetPointSize(4)
actor.filename = filename
return actor
da.InsertNextValue(ntris)
da2 = vtk.vtkIntArray()
da2.SetNumberOfTuples(1)
contr.AllReduce(da, da2, vtk.vtkCommunicator.SUM_OP)
if rank == 0:
print(da2.GetValue(0))
import os
os.remove(filename)
for i in range(npieces):
if not useSubdir:
os.remove(VTK_TEMP_DIR + "/%s_%d.%s" % (dataType, i, ext))
else:
os.remove(VTK_TEMP_DIR + "/%s/%s_%d.%s" %(dataType, dataType, i, ext))
assert da2.GetValue(0) == numTris
TestDataType('ImageData', vtk.vtkXMLPImageDataReader(), vtk.vtkXMLPImageDataWriter(), 'vti', 4924)
TestDataType('RectilinearGrid', vtk.vtkXMLPRectilinearGridReader(), vtk.vtkXMLPRectilinearGridWriter(), 'vtr', 4924)
TestDataType('StructuredGrid', vtk.vtkXMLPStructuredGridReader(), vtk.vtkXMLPStructuredGridWriter(), 'vts', 4924)
TestDataType('UnstructuredGrid', vtk.vtkXMLPUnstructuredGridReader(), vtk.vtkXMLPUnstructuredGridWriter(), 'vtu', 11856)
TestDataType('Table', vtk.vtkXMLPTableReader(), vtk.vtkXMLPTableWriter(), 'vtt', 18522)
# Test writers with UseSubdirectory on
TestDataType('ImageData', vtk.vtkXMLPImageDataReader(), vtk.vtkXMLPImageDataWriter(), 'vti', 4924, useSubdir=True)
TestDataType('RectilinearGrid', vtk.vtkXMLPRectilinearGridReader(), vtk.vtkXMLPRectilinearGridWriter(), 'vtr', 4924, useSubdir=True)
TestDataType('StructuredGrid', vtk.vtkXMLPStructuredGridReader(), vtk.vtkXMLPStructuredGridWriter(), 'vts', 4924, useSubdir=True)
TestDataType('UnstructuredGrid', vtk.vtkXMLPUnstructuredGridReader(), vtk.vtkXMLPUnstructuredGridWriter(), 'vtu', 11856, useSubdir=True)
TestDataType('Table', vtk.vtkXMLPTableReader(), vtk.vtkXMLPTableWriter(), 'vtt', 18522, useSubdir=True)
cf.SetValue(0, 130)
cf.SetComputeNormals(0)
cf.SetComputeGradients(0)
cf.SetInputConnection(reader.GetOutputPort())
cf.UpdateInformation()
cf.GetOutputInformation(0).Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_NUMBER_OF_PIECES(), nranks)
cf.GetOutputInformation(0).Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_PIECE_NUMBER(), rank)
cf.Update()
ntris = cf.GetOutput().GetNumberOfCells()
da = vtk.vtkIntArray()
da.InsertNextValue(ntris)
da2 = vtk.vtkIntArray()
da2.SetNumberOfTuples(1)
contr.AllReduce(da, da2, vtk.vtkCommunicator.SUM_OP)
if rank == 0:
print(da2.GetValue(0))
import os
os.remove(filename)
for i in range(npieces):
os.remove(VTK_TEMP_DIR + "/%s_%d.%s" % (dataType, i, ext))
assert da2.GetValue(0) == numTris
TestDataType('ImageData', vtk.vtkXMLPImageDataReader(), vtk.vtkXMLPImageDataWriter(), 'vti', 4924)
TestDataType('RectilinearGrid', vtk.vtkXMLPRectilinearGridReader(), vtk.vtkXMLPRectilinearGridWriter(), 'vtr', 4924)
TestDataType('StructuredGrid', vtk.vtkXMLPStructuredGridReader(), vtk.vtkXMLPStructuredGridWriter(), 'vts', 4924)
TestDataType('UnstructuredGrid', vtk.vtkXMLPUnstructuredGridReader(), vtk.vtkXMLPUnstructuredGridWriter(), 'vtu', 11856)