def main():
# The sphere and spikes are appended into a single polydata.
# This just makes things simpler to manage.
# apd = vtk.vtkUnstructuredGridReader()
data_source = vtk.vtkRectilinearGridReader()
data_source.SetFileName("/home/saito/paraview/solution_40.vtk")
data_source.SetScalarsName("Pressure")
# Create the RenderWindow, Renderer and both Actors
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
implicit_plane_widget, selected_plane_actor = new_implicit_plane_widget(
data_source)
implicit_plane_widget.SetInteractor(iren)
ren.AddActor(new_geometry_actor(data_source))
ren.AddActor(selected_plane_actor)
ren.AddActor(new_outline_actor(data_source))
ren.AddActor(new_axes_actor(ren, data_source))
# Add the actors to the renderer, set the background and size
ren.SetBackground(1, 1, 1)
renWin.SetSize(300, 300)
ren.SetBackground(0.1, 0.2, 0.4)
# Start interaction.
iren.Initialize()
renWin.Render()
iren.Start()
def read_vtk(self, to_polydata=False):
# Read the source file.
reader = vtk.vtkDataReader()
reader.SetFileName('.'.join([self.filename, self.input_type]))
reader.Update()
print('Case ID : {}, input type: {}'.format(self.filename,
self.input_type))
if reader.IsFileUnstructuredGrid():
print('Reading Unstructured Grid...')
reader = vtk.vtkUnstructuredGridReader()
elif reader.IsFilePolyData():
print('Reading Polygonal Mesh...')
reader = vtk.vtkPolyDataReader()
elif reader.IsFileStructuredGrid():
print('Reading Structured Grid...')
reader = vtk.vtkStructuredGridReader()
elif reader.IsFileStructuredPoints():
print('Reading Structured Points...')
reader = vtk.vtkStructuredPointsReader()
elif reader.IsFileRectilinearGrid():
print('Reading Rectilinear Grid...')
reader = vtk.vtkRectilinearGridReader()
else:
print('Data format unknown...')
reader.SetFileName(self.filename + '.' + self.input_type)
reader.Update() # Needed because of GetScalarRange
scalar_range = reader.GetOutput().GetScalarRange()
if to_polydata and not reader.IsFilePolyData():
print('Transform to Polygonal Mesh')
reader = self.unstructured_grid_to_poly_data(reader)
print('Scalar range: \n{}'.format(scalar_range))
return reader, scalar_range
def my_vtk(fdir, fname, varname):
"""
Get vtk-reader from filename and varname
Parameters
----------
fdir : string
Path to the file. Without '/' at end.
fname : string
Name of the file.
varname: string
Name of the variable
Returns
----------
vtk_reader: vtk Reader instance
vtk Reader containing information about a vtk-file.
"""
# Check if scalar variable is in vtk-file
is_var_in_file(fdir, fname, varname)
# Prepare vtk-Reader
vtk_reader = vtk.vtkRectilinearGridReader() # Reader
vtk_reader.SetFileName(fdir + '/' + fname) # Filename
vtk_reader.SetScalarsName(varname) # Variable name
vtk_reader.Update() # Refresh
return vtk_reader
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkRectilinearGridReader(), 'Reading vtkRectilinearGrid.',
(), ('vtkRectilinearGrid',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def loadRectilinearGrid(filename): # not tested
'''Load a vtkRectilinearGrid object from file and return a vtkActor.'''
reader = vtk.vtkRectilinearGridReader()
reader.SetFileName(filename)
reader.Update()
gf = vtk.vtkRectilinearGridGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
return Actor(gf.GetOutput())
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkRectilinearGridReader(),
'Reading vtkRectilinearGrid.', (),
('vtkRectilinearGrid', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def create_reader (self):
"Create the corresponding reader."
debug ("In VtkDataReader::create_reader ()")
# set up the reader
if self.file_name == "":
raise IOError, "No filename specifed for the data handler!"
self.grid_type = find_data_type (self.file_name)
if self.grid_type == "STRUCTURED_GRID":
self.reader = vtk.vtkStructuredGridReader ()
elif self.grid_type == "STRUCTURED_POINTS":
self.reader = vtk.vtkStructuredPointsReader ()
elif self.grid_type == "RECTILINEAR_GRID":
self.reader = vtk.vtkRectilinearGridReader ()
elif self.grid_type == "POLYDATA":
self.reader = vtk.vtkPolyDataReader ()
elif self.grid_type == "UNSTRUCTURED_GRID":
self.reader = vtk.vtkUnstructuredGridReader ()
def pluto_vtk_to_numpy(filename, quantity_names, ordering):
'''pluto_vtk_to_numpy(filename, quantity_names, ordering): \
loads a vtk as built by pluto \
(only for scalar output of quantities)\
and converts it to numpy array.\
"ordering may be either "C" or "F"'''
if (os.path.isfile(filename)):
reader = vtkRectilinearGridReader()
reader.SetFileName(filename)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
else:
raise ValueError("File '" + filename + "' does not exist")
data = reader.GetOutput()
dim = []
for ii in data.GetDimensions():
if ii > 1:
dim.append(ii)
x = VN.vtk_to_numpy(data.GetXCoordinates())
y = VN.vtk_to_numpy(data.GetYCoordinates())
z = VN.vtk_to_numpy(data.GetZCoordinates())
u = []
for qn in quantity_names:
# I transform to numpy array the scalar/vector field (and reshape)
u.append(VN.vtk_to_numpy(data.GetCellData().GetArray(qn)))
# Number of cells per each dimension
dim_cells = list(np.array(dim) - 1)
dim_quantity = dim_cells.copy()
for ii in range(len(u)):
try:
dim_quantity.append(u[ii].shape[1])
except IndexError:
pass
u[ii] = u[ii].reshape(dim_quantity, order=ordering).transpose()
return u, x, y, z
def load_object_3d(self, path, viewer_3d):
generic_reader = vtkDataReader()
generic_reader.SetFileName(path)
if generic_reader.OpenVTKFile() and generic_reader.ReadHeader():
if generic_reader.IsFileStructuredPoints():
raise Exception("Cannot read VTK structured points")
elif generic_reader.IsFilePolyData():
reader = vtkPolyDataReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileStructuredGrid():
reader = vtkStructuredGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileUnstructuredGrid():
reader = vtkUnstructuredGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileRectilinearGrid():
reader = vtkRectilinearGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
else:
raise Exception("Cannot read VTK file containing type %i" %
generic_reader.GetFileType())
viewer_3d.objects_3d.append(object_3d)
else:
importer = vtkVRMLImporter()
importer.SetFileName(path)
importer.Update()
actors = importer.GetRenderer().GetActors()
number_of_actors = actors.GetNumberOfItems()
actors.InitTraversal()
for i in range(number_of_actors):
actor = actors.GetNextItem()
object_3d = Object3D(path + ", %i" % i)
object_3d.actor.SetProperty(actor.GetProperty())
object_3d.actor.SetMapper(actor.GetMapper())
viewer_3d.objects_3d.append(object_3d)
def _load_file(self, filename):
"""
Load a rectilinear grid from a file.
The file extension will select the type of reader to use. A .vtk
extension will use the legacy reader, while .vtr 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('{} does not exist'.format(filename))
# Check file extension
if '.vtr' in filename:
legacy_writer = False
elif '.vtk' in filename:
legacy_writer = True
else:
raise Exception(
'Extension should be either ".vtr" (xml) or ".vtk" (legacy)')
# Create reader
if legacy_writer:
reader = vtk.vtkRectilinearGridReader()
else:
reader = vtk.vtkXMLRectilinearGridReader()
# load file to self
reader.SetFileName(filename)
reader.Update()
grid = reader.GetOutput()
self.shallow_copy(grid)
import vtk
#help(vtk.vtkRectilinearGridReader())
rectGridReader = vtk.vtkRectilinearGridReader()
rectGridReader.SetFileName("data/jet4_0.500.vtk")
# do not forget to call "Update()" at the end of the reader
rectGridReader.Update()
rectGridOutline = vtk.vtkRectilinearGridOutlineFilter()
rectGridOutline.SetInputData(rectGridReader.GetOutput())
# New vtkRectilinearGridGeometryFilter() goes here:
#
#
#
#
plane = vtk.vtkRectilinearGridGeometryFilter()
plane.SetInputData(rectGridReader.GetOutput())
rectGridOutlineMapper = vtk.vtkPolyDataMapper()
rectGridOutlineMapper.SetInputConnection(rectGridOutline.GetOutputPort())
rectGridGeomMapper = vtk.vtkPolyDataMapper()
rectGridGeomMapper.SetInputConnection(plane.GetOutputPort())
#
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(rectGridOutlineMapper)
outlineActor.GetProperty().SetColor(0, 0, 0)
gridGeomActor = vtk.vtkActor()
def loadRectilinearGrid(filename):
"""Load a ``vtkRectilinearGrid`` object from file."""
reader = vtk.vtkRectilinearGridReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
extents = (1, 3, 1, 3, 1, 3)
rg.SetExtent(extents)
pts = vtk.vtkFloatArray()
pts.InsertNextTuple1(0)
pts.InsertNextTuple1(1)
pts.InsertNextTuple1(2)
rg.SetXCoordinates(pts)
rg.SetYCoordinates(pts)
rg.SetZCoordinates(pts)
w = vtk.vtkRectilinearGridWriter()
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.Write()
r = vtk.vtkRectilinearGridReader()
r.SetFileName("test-dim.vtk")
r.Update()
os.remove("test-dim.vtk")
assert(r.GetOutput().GetExtent() == (0,2,0,2,0,2))
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.SetWriteExtent(True)
w.Write()
r.Modified()
r.Update()
def read_polydata(filename, datatype=None):
"""
Load the given file, and return a vtkPolyData object for it.
Args:
filename (str): Path to input file.
datatype (str): Additional parameter for vtkIdList objects.
Returns:
polyData (vtkSTL/vtkPolyData/vtkXMLStructured/
vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
vtkXMLImage/Tecplot): Output data.
"""
# Check if file exists
if not path.exists(filename):
raise RuntimeError("Could not find file: %s" % filename)
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise RuntimeError('The file does not have an extension')
# Get reader
if fileType == 'stl':
reader = vtk.vtkSTLReader()
reader.MergingOn()
elif fileType == 'vtk':
# Read header
with open(filename, "rb") as f:
head = list(islice(f, 10))
head = "".join([l.decode('utf-8', 'backslashreplace')
for l in head]).lower()
# Set reader based on header
if "unstructured_grid" in head:
reader = vtk.vtkUnstructuredGridReader()
elif "structured_grid" in head:
reader = vtk.vtkStructuredGridReader()
elif "rectilinear_grid" in head:
reader = vtk.vtkRectilinearGridReader()
elif "structured_points" in head:
reader = vtk.vtkStructuredPointsReader()
elif "polydata" in head:
reader = vtk.vtkPolyDataReader()
elif fileType == 'vtp':
reader = vtk.vtkXMLPolyDataReader()
elif fileType == 'vts':
reader = vtk.vtkXMLStructuredGridReader()
elif fileType == 'vtr':
reader = vtk.vtkXMLRectilinearGridReader()
elif fileType == 'vtu':
reader = vtk.vtkXMLUnstructuredGridReader()
elif fileType == "vti":
reader = vtk.vtkXMLImageDataReader()
elif fileType == "np" and datatype == "vtkIdList":
result = np.load(filename).astype(np.int)
id_list = vtk.vtkIdList()
id_list.SetNumberOfIds(result.shape[0])
for i in range(result.shape[0]):
id_list.SetId(i, result[i])
return id_list
else:
raise RuntimeError('Unknown file type %s' % fileType)
# Read
reader.SetFileName(filename)
reader.Update()
polydata = reader.GetOutput()
return polydata
F = np.squeeze(
np.reshape(F, (int(FTLE_Res[1]), int(FTLE_Res[0]), int(
FTLE_Res[2:]), int(LCS_NumFields), int(Output_TRes))))
X = np.linspace(ftlemin[0], ftlemax[0], FTLE_Res[0])
Y = np.linspace(ftlemin[1], ftlemax[1], FTLE_Res[1])
Z = np.linspace(ftlemin[2], ftlemax[2], FTLE_Res[2])
# first time step
nwF = F[:, :, :, :]
FTLE = nwF[:, :, :, 0] # .T.swapaxes(1, 2)
Omega = nwF[:, :, :, 1] # .T.swapaxes(1, 2)
Eval = nwF[:, :, :, 2] # .T.swapaxes(1, 2)
smFTLE = nwF[:, :, :, 3] # .T.swapaxes(1, 2)
reader = vtkRectilinearGridReader()
reader.SetFileName(fname)
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.Update()
data = reader.GetOutput()
dim = data.GetDimensions()
bounds = data.GetBounds()
arrowGlyph = data.GetPointData().GetArray('U')
vectU = VN.vtk_to_numpy(arrowGlyph)
vectU[vectU < -99] = -1
vectXYZ = vectU
vectX = vectXYZ[:, 0]
# msk = np.reshape(vectX, [dim[0], dim[1], dim[2]], order='F')
# msk[msk > -1] = 1
# msk[msk < 1] = 0
