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 __init__(self):
self.files = []
self.timestep = -1
self.geometry = vtk.vtkUnstructuredGridReader()
self.geometry_mapper = vtk.vtkDataSetMapper()
self.geometry_actor = vtk.vtkActor()
self.positions = vtk.vtkUnstructuredGridReader()
self.positions_mapper = vtk.vtkDataSetMapper()
self.positions_actor = vtk.vtkActor()
self.geometry_mapper.SetInput(self.geometry.GetOutput())
self.positions_mapper.SetInput(self.positions.GetOutput())
self.positions_mapper.ScalarVisibilityOff()
self.geometry_actor.SetMapper(self.geometry_mapper)
self.geometry_actor.GetProperty().SetOpacity(0.2)
self.positions_actor.SetMapper(self.positions_mapper)
self.positions_actor.GetProperty().SetColor(light_grey)
self.ren = vtk.vtkRenderer()
self.ren_win = GtkGLExtVTKRenderWindow()
self.ren_win.GetRenderWindow().AddRenderer(self.ren)
self.ren.AddActor(self.geometry_actor)
self.ren.AddActor(self.positions_actor)
self.ren.SetBackground(0.1, 0.2, 0.4)
def __init__(self):
self.files = []
self.timestep = -1
self.geometry = vtk.vtkUnstructuredGridReader()
self.geometry_mapper = vtk.vtkDataSetMapper()
self.geometry_actor = vtk.vtkActor()
self.positions = vtk.vtkUnstructuredGridReader()
self.positions_mapper = vtk.vtkDataSetMapper()
self.positions_actor = vtk.vtkActor()
self.geometry_mapper.SetInput(self.geometry.GetOutput())
self.positions_mapper.SetInput(self.positions.GetOutput())
self.positions_mapper.ScalarVisibilityOff()
self.geometry_actor.SetMapper(self.geometry_mapper)
self.geometry_actor.GetProperty().SetOpacity(0.2)
self.positions_actor.SetMapper(self.positions_mapper)
self.positions_actor.GetProperty().SetColor(light_grey)
self.ren = vtk.vtkRenderer()
self.ren_win = GtkGLExtVTKRenderWindow()
self.ren_win.GetRenderWindow().AddRenderer(self.ren)
self.ren.AddActor(self.geometry_actor)
self.ren.AddActor(self.positions_actor)
self.ren.SetBackground(0.1, 0.2, 0.4)
def read_ugrid(filename):
if filename.endswith(".pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif filename.endswith(".vtk"):
reader = vtk.vtkUnstructuredGridReader()
elif filename.endswith(".vtu"):
reader = vtk.vtkUnstructuredGridReader()
else:
raise BaseException("Illegal filename suffix %s" % filename)
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def read_ugrid(filename):
if filename.endswith(".pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif filename.endswith(".vtk"):
reader = vtk.vtkUnstructuredGridReader()
elif filename.endswith(".vtu"):
reader = vtk.vtkUnstructuredGridReader()
else:
raise BaseException("Illegal filename suffix %s" % filename)
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
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 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 vtk_contours_actor(filename, count=10, color=False):
import vtk
# read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# contours
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort())
contours.GenerateValues(count, scalar_range)
# map the contours to graphical primitives
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInput(contours.GetOutput())
contMapper.SetScalarVisibility(color) # colored contours
contMapper.SetScalarRange(scalar_range)
# create an actor for the contours
contActor = vtk.vtkActor()
contActor.SetMapper(contMapper)
contActor.GetProperty().SetColor(0.2, 0.2, 0.2)
contActor.GetProperty().SetLineWidth(1)
return contActor
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 unstructered_grid_reader(filename):
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# Create the mapper that corresponds the objects of the vtk file
# into graphics elements
mapper =vtk.vtkDataSetMapper()
mapper.SetInputData(output)
mapper.SetScalarRange(scalar_range)
# Create the Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create the Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1) # Set background to white
# Create the RendererWindow
renderer_window = vtk.vtkRenderWindow()
renderer_window.AddRenderer(renderer)
# Create the RendererWindowInteractor and display the vtk_file
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer_window)
interactor.Initialize()
interactor.Start()
def render_vtk(file_name):
import vtk
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# Create the mapper that corresponds the objects of the vtk.vtk file
# into graphics elements
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(output)
mapper.SetScalarRange(scalar_range)
# Create the Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create the Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1) # Set background to white
# Create the RendererWindow
renderer_window = vtk.vtkRenderWindow()
renderer_window.AddRenderer(renderer)
# Create the RendererWindowInteractor and display the vtk_file
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer_window)
interactor.Initialize()
interactor.Start()
def get_node_data_n(self, file_name): """ Reads mesh information. Returns a numpy arrays of nodes & elements in 'abaqus' format. """ meshSource=vtk.vtkUnstructuredGridReader() meshSource.SetFileName(file_name) meshSource.Update() #get nodes & elements returned to numpy arrays nread=v2n(meshSource.GetOutput().GetPoints().GetData()) #allocate for extra node numbers to be input node_data=np.zeros((np.shape(nread)[0],np.shape(nread)[1]+1)) #reshape according to 'abaqus' standards (node num, coord1, 2 ...) node_data[:,0]=np.arange(np.shape(nread)[0])+1 node_data[:,1:]=nread # print([np.shape(np.arange(np.shape(n)[0])].transpose())) e=v2n(meshSource.GetOutput().GetCells().GetData()) #get cell types & reshape element array as needed. tcs=vtk.vtkCellTypes() meshSource.GetOutput().GetCellTypes(tcs) #reshape according to 'abaqus' standards (elem number, connectivity1 2 ...) if tcs.IsType(12)==1: self.mainCellType=12 #1st order quad element_data=np.resize(e,(int(len(e)/float(9)),9)) element_data[:,0]=np.arange(np.shape(element_data)[0])+1 elif tcs.IsType(24)==1: self.mainCellType=24 #2nd order tet element_data=np.resize(e,(int(len(e)/float(11)),11)) element_data[:,0]=np.arange(np.shape(element_data)[0])+1 # print(np.shape(node_data),np.shape(element_data)) #debug return node_data, element_data+1 #add one to the element number to match abaqus format
def read_data_and_build_snapshot_matrix(x_min,x_max,y_min,y_max,z_min,z_max,snapshot_dir,file_list,\
num_snapshots,num_points,num_components,var_name, A):
reader = vtk.vtkUnstructuredGridReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
extract_region = "false"
if ((x_min < x_max) and (y_min < y_max) and (z_min < z_max)):
extract_region = "true"
extract = vtk.vtkExtractUnstructuredGrid()
extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max)
extract.MergingOn()
u_temp_read = np.array(np.zeros((num_points, 3), dtype=np.float64))
print '\n Reading data ...'
for j in range(0, num_snapshots + 1):
print ' Reading file ', file_list[j].strip(
), 'file number ', j, ' of ', num_snapshots
reader.SetFileName(snapshot_dir + file_list[j].strip())
reader.Update()
if (extract_region == "true"):
extract.SetInput(reader.GetOutput())
extract.Update()
u_temp_read = VN.vtk_to_numpy(
extract.GetOutput().GetPointData().GetVectors(var_name))
else:
u_temp_read = VN.vtk_to_numpy(
reader.GetOutput().GetPointData().GetVectors(var_name))
for k in range(0, num_components):
A[k * num_points:(k + 1) * num_points, j] = u_temp_read[:, k]
def loadVtk(self, fname):
""" Load a given VTK file into a vtkPolyData object """
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
self._vtk = reader.GetOutput()
def read_vtk(self, data_dir='./data', file_name='separatrices.vtk'):
"""
Read the separatrices from a vtk file.
call signature:
read_vtk(data_dir='./data', file_name='separatrices.vtk')
Arguments:
*data_dir*:
Origin data directory.
*file_name*:
Origin file name.
"""
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(os.path.join(data_dir, file_name))
reader.Update()
output = reader.GetOutput()
# Read the separatrices.
points = output.GetPoints()
cells = output.GetCells()
self.separatrices = []
self.connectivity = []
for separatrix in range(points.GetNumberOfPoints()):
self.separatrices.append(points.GetPoint(separatrix))
self.separatrices = np.array(self.separatrices)
self.connectivity = np.array([
VN.vtk_to_numpy(cells.GetData())[1::3],
VN.vtk_to_numpy(cells.GetData())[2::3]
])
self.connectivity = self.connectivity.swapaxes(0, 1)
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 read_data_and_build_snapshot_matrix(x_min,x_max,y_min,y_max,z_min,z_max,snapshot_dir,file_list,\ num_snapshots,num_points,num_components,var_name, A): reader = vtk.vtkUnstructuredGridReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() extract_region = "false" if ( (x_min<x_max) and (y_min<y_max) and (z_min<z_max) ): extract_region = "true" extract = vtk.vtkExtractUnstructuredGrid() extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max) extract.MergingOn() u_temp_read = np.array(np.zeros((num_points,3), dtype=np.float64)) print '\n Reading data ...' for j in range(0,num_snapshots+1): print ' Reading file ', file_list[j].strip(), 'file number ', j, ' of ', num_snapshots reader.SetFileName(snapshot_dir + file_list[j].strip()) reader.Update() if (extract_region=="true"): extract.SetInput(reader.GetOutput()) extract.Update() u_temp_read = VN.vtk_to_numpy(extract.GetOutput().GetPointData().GetVectors(var_name)) else: u_temp_read = VN.vtk_to_numpy(reader.GetOutput().GetPointData().GetVectors(var_name)) for k in range(0,num_components): A[k*num_points:(k+1)*num_points,j] = u_temp_read[:,k]
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 __init__(self, vtk_filename=None, vtk_data=None):
"""
Initiate Viwer
Parameters
----------
vtk_filename : str
Input VTK filename
"""
QDialog.__init__(self)
self.initUI()
ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(ren)
iren = self.vtkWidget.GetRenderWindow().GetInteractor()
if vtk_filename is not None:
# VTK file
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(vtk_filename)
reader.Update()
vtkdata = reader.GetOutput()
if vtk_data is not None:
vtkdata = vtk_data
# VTK surface
surface = vtk.vtkDataSetSurfaceFilter()
surface.SetInput(vtkdata)
surface.Update()
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(surface.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOff()
# actor.GetProperty().SetEdgeColor(1,1,1)
# actor.GetProperty().SetLineWidth(0.1)
ren.AddActor(actor)
# annot. cube
axesActor = vtk.vtkAnnotatedCubeActor()
axesActor.SetXPlusFaceText('R')
axesActor.SetXMinusFaceText('L')
axesActor.SetYMinusFaceText('H')
axesActor.SetYPlusFaceText('F')
axesActor.SetZMinusFaceText('A')
axesActor.SetZPlusFaceText('P')
axesActor.GetTextEdgesProperty().SetColor(1, 1, 0)
axesActor.GetCubeProperty().SetColor(0, 0, 1)
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axesActor)
self.axes.SetInteractor(iren)
self.axes.EnabledOn()
self.axes.InteractiveOn()
ren.ResetCamera()
iren.Initialize()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkUnstructuredGridReader(), 'Reading vtkUnstructuredGrid.',
(), ('vtkUnstructuredGrid',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def vtkReadVTKfile(self, filename):
""" Lecture d'un fichier vtk"""
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update() # Needed because of GetScalarRange
surface_filter = vtk.vtkDataSetSurfaceFilter()
surface_filter.SetInputConnection(reader.GetOutputPort())
self.meshNormals = vtk.vtkPolyDataNormals()
self.meshNormals.SetInputConnection(surface_filter.GetOutputPort())
self.meshNormals.SetFeatureAngle(60.0)
self.meshNormals.ComputeCellNormalsOn()
self.meshNormals.ComputePointNormalsOn()
self.meshNormals.ConsistencyOn()
self.meshNormals.AutoOrientNormalsOn()
self.meshNormals.Update()
# Sauvegarde des proprietes maillage GMSH pour calcul centerline
self.gmeshNode = vtk_to_np(surface_filter.GetOutput().GetPoints().GetData())
self.gmeshTable = vtk_to_np(surface_filter.GetOutput().GetPolys().GetData())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
self.outputMesh = vtk.vtkCleanPolyData()
self.outputMesh.SetInputConnection(surface_filter.GetOutputPort())
self.outputMesh.SetTolerance(0.001)
def vtkReadVTKfile(self, filename='not defined'):
""" Lecture d'un fichier vtk"""
# Read the source file.
print "----------------------------------------------------"
print "Read geometric surface"
print "----------------------------------------------------"
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(os.path.join(self.read_path, filename))
reader.Update() # Needed because of GetScalarRange
surface_filter = vtk.vtkDataSetSurfaceFilter()
surface_filter.SetInputConnection(reader.GetOutputPort())
self.meshNormals = vtk.vtkPolyDataNormals()
self.meshNormals.SetInputConnection(surface_filter.GetOutputPort())
self.meshNormals.Update()
#~ self.normales = VN.vtk_to_numpy(self.meshNormals.GetOutput().GetPointData().GetNormals())
self.meshNode = VN.vtk_to_numpy(
surface_filter.GetOutput().GetPoints().GetData())
self.meshTable = VN.vtk_to_numpy(
surface_filter.GetOutput().GetPolys().GetData())
self.meshTable = self.meshTable.reshape(self.meshTable.shape[0] / 4,
4)[:, 1:]
self.nbDof = self.meshNode.shape[0]
self.nbElem = self.meshTable.shape[0]
def vtk_contours_actor(filename, count=10, color=False):
import vtk
# read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# contours
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort())
contours.GenerateValues(count, scalar_range)
# map the contours to graphical primitives
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInput(contours.GetOutput())
contMapper.SetScalarVisibility(color) # colored contours
contMapper.SetScalarRange(scalar_range)
# create an actor for the contours
contActor = vtk.vtkActor()
contActor.SetMapper(contMapper)
contActor.GetProperty().SetColor(0.2, 0.2, 0.2)
contActor.GetProperty().SetLineWidth(1)
return contActor
def read_vtk(self, data_dir='./data', file_name='separatrices.vtk'):
"""
Read the separatrices from a vtk file.
call signature:
read_vtk(data_dir='./data', file_name='separatrices.vtk')
Arguments:
*data_dir*:
Origin data directory.
*file_name*:
Origin file name.
"""
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(os.path.join(data_dir, file_name))
reader.Update()
output = reader.GetOutput()
# Read the separatrices.
points = output.GetPoints()
cells = output.GetCells()
self.separatrices = []
self.connectivity = []
for separatrix in range(points.GetNumberOfPoints()):
self.separatrices.append(points.GetPoint(separatrix))
self.separatrices = np.array(self.separatrices)
self.connectivity = np.array([VN.vtk_to_numpy(cells.GetData())[1::3],
VN.vtk_to_numpy(cells.GetData())[2::3]])
self.connectivity = self.connectivity.swapaxes(0, 1)
def __init__(self):
"""
Constructor
no args
"""
# (dstCellId, srcCellId) -> weight as a 4x4 matrix
self.weights = {}
self.srcReader = vtk.vtkUnstructuredGridReader()
self.srcGrid = vtk.vtkUnstructuredGrid()
self.srcLoc = vtk.vtkCellLocator()
self.srcEdgeField = []
self.dstReader = vtk.vtkUnstructuredGridReader()
self.dstGrid = vtk.vtkUnstructuredGrid()
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 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 get_number_of_points_and_boundary_faces(pod_mode_dir,calibrate_coefficients): filename = pod_mode_dir+"/spatial_meanfield.vtk" reader = vtk.vtkUnstructuredGridReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.ReadAllTensorsOn() reader.SetFileName(filename) reader.Update() num_points = reader.GetOutput().GetNumberOfPoints() if( (calibrate_coefficients=="none") or (calibrate_coefficients=="constant") ): geom_filter = vtk.vtkDataSetSurfaceFilter() geom_filter.SetInput(reader.GetOutput()) geom_filter.Update() boundary_faces = vtk.vtkPolyData() boundary_faces = geom_filter.GetOutput() point_to_cell_data = vtk.vtkPointDataToCellData() point_to_cell_data.SetInput(geom_filter.GetOutput()) point_to_cell_data.Update() num_boundary_faces = point_to_cell_data.GetOutput().GetNumberOfCells() else: num_boundary_faces = 1 return num_points, num_boundary_faces
def importVTKMeshFile(fnVTK,
bkgdColor=[255, 255, 255],
color=[0, 0, 0],
renderer=None):
"""Imports a .vtk file into a vtk renderer and draws it as a wireframe.
See also :py:func:`pyfrp.modules.pyfrp_vtk_module.unstructedGridToWireframe`.
Keyword Args:
fnVTK (str): Path to input vtk file.
bkgdColor (list): Background color in RGB values.
color (list): Color of mesh in RGB values.
renderer (vtk.vtkRenderer): Some renderer.
Returns:
vtk.vtkRenderer: Renderer object.
"""
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(fnVTK)
reader.Update()
output = reader.GetOutput()
return unstructedGridToMesh(output,
bkgdColor=bkgdColor,
color=color,
renderer=None)
def get_number_of_points_and_boundary_faces(pod_mode_dir,
calibrate_coefficients):
filename = pod_mode_dir + "/spatial_meanfield.vtk"
reader = vtk.vtkUnstructuredGridReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.ReadAllTensorsOn()
reader.SetFileName(filename)
reader.Update()
num_points = reader.GetOutput().GetNumberOfPoints()
if ((calibrate_coefficients == "none")
or (calibrate_coefficients == "constant")):
geom_filter = vtk.vtkDataSetSurfaceFilter()
geom_filter.SetInput(reader.GetOutput())
geom_filter.Update()
boundary_faces = vtk.vtkPolyData()
boundary_faces = geom_filter.GetOutput()
point_to_cell_data = vtk.vtkPointDataToCellData()
point_to_cell_data.SetInput(geom_filter.GetOutput())
point_to_cell_data.Update()
num_boundary_faces = point_to_cell_data.GetOutput().GetNumberOfCells()
else:
num_boundary_faces = 1
return num_points, num_boundary_faces
def read_vtk(filename) : import vtk import numpy as np reader=vtk.vtkUnstructuredGridReader() reader.SetFileName(filename) reader.Update() nbvv=reader.GetNumberOfVectorsInFile() nbss=reader.GetNumberOfScalarsInFile() m1=reader.GetOutput() numpoints=m1.GetNumberOfPoints() points=m1.GetPoints() xyz=np.zeros((numpoints,3)) for k in range(numpoints): xyz[k,0],xyz[k,1],xyz[k,2]=points.GetPoint(k) pointData=m1.GetPointData() nba=pointData.GetNumberOfArrays() S=np.zeros((numpoints,3*nba*nbvv+nbss*nba)) l=0 for i in range(nbss*nba): a=pointData.GetArrayName(i) ve=pointData.GetScalars(a) for k in range(numpoints): S[k,0+l]=ve.GetTuple1(k) l=l+1 ll=0 for i in range(nbvv*nba): a=pointData.GetArrayName(i) ve=pointData.GetVectors(a) for k in range(numpoints): S[k,l+ll*3],S[k,l+1+ll*3],S[k,l+2+ll*3]=ve.GetTuple3(k) ll=ll+1 return xyz[:numpoints/2,:],S[:numpoints/2,:],nba*nbvv,nba*nbss
def loadVtk(self, fname):
""" Load a given VTK file into a vtkPolyData object """
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
self._vtk = reader.GetOutput()
def get_data(inputf="input.vtk"):
# open file and load data into reader object
filename = inputf
reader = vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
# move data to data and extract the numpy vectors
data = reader.GetOutput()
x = np.zeros(data.GetNumberOfPoints())
y = np.zeros(data.GetNumberOfPoints())
z = np.zeros(data.GetNumberOfPoints())
for i in range(data.GetNumberOfPoints()):
x[i],y[i],z[i] = data.GetPoint(i)
# how many vectors and with how many points each
n_arrays = data.GetPointData().GetNumberOfArrays()
n_points = data.GetNumberOfPoints()
array = np.zeros((n_arrays,n_points))
names = [0]*n_arrays
# load the data in the numpy structures we have created
for i in range(n_arrays):
array[i] = VN.vtk_to_numpy(data.GetPointData().GetArray(i))
names[i] = data.GetPointData().GetArray(i).GetName()
return(x,array,names)
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 getReader(self, model_type=None):
self.model_type = model_type
if self.model_type == 'UnstructuredGrid':
return vtk.vtkUnstructuredGridReader()
elif self.model_type == 'PolyData':
return vtk.vtkPolyDataReader()
else:
raise ValueError("model type informed is unknow...")
def getReader(self, model_type=None):
self.model_type = model_type
if self.model_type == 'UnstructuredGrid':
return vtk.vtkUnstructuredGridReader()
elif self.model_type == 'PolyData':
return vtk.vtkPolyDataReader()
else:
raise ValueError("model type informed is unknow...")
def getData_2(filename):
# Read CELL_DATA from vtk file
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_points_arrays= reader.GetOutput().GetPointData()
vtk_cell_arrays = reader.GetOutput().GetCellData()
return vtk_points_arrays, vtk_cell_arrays
def ReadVTKMeshFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading VTK mesh file.')
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Mesh = reader.GetOutput()
def ReadVTKMeshFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading VTK mesh file.')
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Mesh = reader.GetOutput()
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
# The source file
file_name = get_program_parameters()
# Create a custom lut. The lut is used for both at the mapper and at the
# scalar_bar
lut = vtk.vtkLookupTable()
lut.Build()
# Read the source file.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(file_name)
reader.Update() # Needed because of GetScalarRange
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(output)
mapper.SetScalarRange(scalar_range)
mapper.SetLookupTable(lut)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('MidnightBLue'))
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(300, 300)
render_window.SetWindowName("ScalarBarWidget")
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
# create the scalar_bar
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(lut)
# create the scalar_bar_widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(interactor)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
interactor.Initialize()
render_window.Render()
renderer.GetActiveCamera().SetPosition(-6.4, 10.3, 1.4)
renderer.GetActiveCamera().SetFocalPoint(1.0, 0.5, 3.0)
renderer.GetActiveCamera().SetViewUp(0.6, 0.4, -0.7)
render_window.Render()
interactor.Start()
def __init__(self,
filename,
colour=[1.0, 0.0, 0.0],
visibility=True,
opacity=1.0,
pickable=True):
"""
Creates a new surface model.
:param filename: path to vtk grid file.
:param colour: (R,G,B) where each are floats [0-1]
:param visibility: boolean, True|False
:param opacity: float [0,1]
:param pickable: boolean, True|False
"""
super(VTKUnstructuredGridModel, self).__init__(colour, visibility,
opacity, pickable)
self.source_file = None
self.reader = None
self.source = None
self.cell_data_name = None
self.threshold = None
if filename is not None:
vf.validate_is_file(filename)
if filename.endswith(".vtk"):
self.reader = vtk.vtkUnstructuredGridReader()
elif filename.endswith(".vtu"):
self.reader = vtk.vtkXMLUnstructuredGridReader()
else:
raise TypeError("File is not .vtu or .vtk extension")
self.reader.SetFileName(filename)
self.reader.Update()
self.source = self.reader.GetOutput()
self.source_file = filename
self.name = os.path.basename(self.source_file)
else:
raise ValueError("Filename not specified")
self.threshold = vtk.vtkThreshold()
self.threshold.SetInputData(self.source)
self.threshold.Update()
self.thresholded_data = self.threshold.GetOutput()
self.mapper = vtk.vtkDataSetMapper()
self.mapper.SetInputData(self.thresholded_data)
self.mapper.Update()
self.actor.SetMapper(self.mapper)
self.cell_data_name = self.source.GetCellData().GetArrayName(0)
def createMeshFromPolyDataTetGen(self,
inputPolyData,
outputMeshNode,
additionalParameters=""):
self.abortRequested = False
tempDir = self.createTempDirectory()
self.addLog('Mesh generation is started in working directory: ' +
tempDir)
# Write inputs
qt.QDir().mkpath(tempDir)
inputSurfaceMeshFilePath = os.path.join(tempDir, "mesh.ply")
inputWriter = vtk.vtkPLYWriter()
inputWriter.SetInputData(inputPolyData)
inputWriter.SetFileName(inputSurfaceMeshFilePath)
inputWriter.SetFileTypeToASCII()
inputWriter.Write()
inputParamsTetGen = []
inputParamsTetGen.append("-k" + additionalParameters)
inputParamsTetGen.append(inputSurfaceMeshFilePath)
# Run tetgen
ep = self.startMesher(inputParamsTetGen, self.getTetGenPath())
self.logProcessOutput(ep, self.tetGenFilename)
# Read results
if not self.abortRequested:
outputVolumetricMeshPath = os.path.join(tempDir, "mesh.1.vtk")
outputReader = vtk.vtkUnstructuredGridReader()
outputReader.SetFileName(outputVolumetricMeshPath)
outputReader.ReadAllScalarsOn()
outputReader.ReadAllVectorsOn()
outputReader.ReadAllNormalsOn()
outputReader.ReadAllTensorsOn()
outputReader.ReadAllColorScalarsOn()
outputReader.ReadAllTCoordsOn()
outputReader.ReadAllFieldsOn()
outputReader.Update()
outputMeshNode.SetUnstructuredGridConnection(
outputReader.GetOutputPort())
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
if not outputMeshDisplayNode:
# Initial setup of display node
outputMeshNode.CreateDefaultDisplayNodes()
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
outputMeshDisplayNode.SetEdgeVisibility(True)
outputMeshDisplayNode.SetClipping(True)
# Clean up
if self.deleteTemporaryFiles:
import shutil
shutil.rmtree(tempDir)
self.addLog("Model generation is completed")
def readVTK(self,verbose=False):
self.reader=vtk.vtkUnstructuredGridReader()
try:
self.reader.SetFileName(self.filename)
self.reader.ReadAllScalarsOn()
self.reader.ReadAllVectorsOn()
except:
print 'Could not find file: ',self.filename
return
def readVTK(self, verbose=False):
self.reader = vtk.vtkUnstructuredGridReader()
try:
self.reader.SetFileName(self.filename)
self.reader.ReadAllScalarsOn()
self.reader.ReadAllVectorsOn()
except:
print 'Could not find file: ', self.filename
return
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkUnstructuredGridReader(),
'Reading vtkUnstructuredGrid.', (),
('vtkUnstructuredGrid', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def loadUnStructuredGrid(filename): # not tested
'''Load a vtkunStructuredGrid object from file and return a vtkActor.'''
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
gf = vtk.vtkUnstructuredGridGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
return Actor(gf.GetOutput())
def loadFromVtkFile(self, filename):
"""
Load the grid and gfields form a VTK file
@param filename VTK file
"""
self.reader = vtk.vtkUnstructuredGridReader()
self.reader.SetFileName(filename)
self.reader.Update()
self.vtk['grid'] = reader.GetOutput()
def read_vtk(self, data_dir='./data', file_name='nulls.vtk'):
"""
Read the null point from a vtk file.
call signature:
read_vtk(data_dir='./data', file_name='nulls.vtk')
Arguments:
*data_dir*:
Origin data directory.
*file_name*:
Origin file name.
"""
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(os.path.join(data_dir, file_name))
reader.Update()
output = reader.GetOutput()
# Read the null points.
points = output.GetPoints()
self.nulls = []
for null in range(points.GetNumberOfPoints()):
self.nulls.append(points.GetPoint(null))
self.nulls = np.array(self.nulls)
point_data = output.GetPointData()
eigen_values_vtk = []
eigen_values = []
eigen_vectors_vtk = []
eigen_vectors = []
fan_vectors_vtk = []
fan_vectors = []
for dim in range(3):
eigen_values_vtk.append(
point_data.GetVectors('eigen_value_{0}'.format(dim)))
eigen_values.append(VN.vtk_to_numpy(eigen_values_vtk[-1]))
eigen_vectors_vtk.append(
point_data.GetVectors('eigen_vector_{0}'.format(dim)))
eigen_vectors.append(VN.vtk_to_numpy(eigen_vectors_vtk[-1]))
if dim < 2:
fan_vectors_vtk.append(
point_data.GetVectors('fan_vector_{0}'.format(dim)))
fan_vectors.append(VN.vtk_to_numpy(fan_vectors_vtk[-1]))
sign_trace_vtk = point_data.GetVectors('sign_trace')
sign_trace = VN.vtk_to_numpy(sign_trace_vtk)
normals_vtk = point_data.GetVectors('normal')
normals = VN.vtk_to_numpy(normals_vtk)
self.eigen_values = np.swapaxes(np.array(eigen_values), 0, 1)
self.eigen_vectors = np.swapaxes(np.array(eigen_vectors), 0, 1)
self.fan_vectors = np.swapaxes(np.array(fan_vectors), 0, 1)
self.sign_trace = np.array(sign_trace)
self.normals = np.array(normals)
def getData(filename):
# load a vtk file as input
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
vtk_arrays= reader.GetOutput().GetPointData()
#print vtk_nodes
#print vtk_arrays
return vtk_arrays
def LoadModelAnatomy(vtk_mean):
import numpy as np
import vtk
from vtk.util.numpy_support import vtk_to_numpy
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(vtk_mean)
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.Update()
data = reader.GetOutput()
n_points = data.GetNumberOfPoints()
n_el = data.GetNumberOfCells()
Coords = vtk_to_numpy(data.GetPoints().GetData())
Els = np.zeros((n_el, 4), dtype=int)
for i in range(n_el):
cell_type = data.GetCellType(i)
n_nodes_el = data.GetCell(i).GetPointIds().GetNumberOfIds()
for n_sel in range(n_nodes_el):
Els[i, n_sel] = int(data.GetCell(i).GetPointId(n_sel))
labels = vtk_to_numpy(data.GetPointData().GetArray('labels'))
x_c = vtk_to_numpy(data.GetPointData().GetArray('x_c'))
x_l = vtk_to_numpy(data.GetPointData().GetArray('x_l'))
x_t = vtk_to_numpy(data.GetPointData().GetArray('x_t'))
e_c = vtk_to_numpy(data.GetPointData().GetVectors('e_c'))
e_l = vtk_to_numpy(data.GetPointData().GetVectors('e_l'))
e_t = vtk_to_numpy(data.GetPointData().GetVectors('e_t'))
Node_par_coords = np.zeros((n_points, 4))
Node_par_coords[:, 0] = labels
Node_par_coords[:, 1] = x_c
Node_par_coords[:, 2] = x_l
Node_par_coords[:, 3] = x_t
faces_connectivity = np.array([[0, 2, 1], [0, 1, 3], [1, 2, 3], [2, 0, 3]])
Faces_Endo = []
start_faces = True
for kk in range(n_el):
el_points = Els[kk, :]
for jj in range(4):
if all(labels[int(v)] == 2
for v in el_points[faces_connectivity[jj]]):
if start_faces:
Faces_Endo = np.array(el_points[faces_connectivity[jj]],
dtype=int).reshape(1, -1)
start_faces = False
else:
Faces_Endo = np.concatenate(
(Faces_Endo,
np.array(el_points[faces_connectivity[jj]],
dtype=int).reshape(1, -1)), 0)
return Coords, Els, n_points, n_el, Node_par_coords, e_t, e_l, e_c, Faces_Endo
def read_vtk(self, data_dir='./data', file_name='nulls.vtk'):
"""
Read the null point from a vtk file.
call signature:
read_vtk(data_dir='./data', file_name='nulls.vtk')
Arguments:
*data_dir*:
Origin data directory.
*file_name*:
Origin file name.
"""
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(os.path.join(data_dir, file_name))
reader.Update()
output = reader.GetOutput()
# Read the null points.
points = output.GetPoints()
self.nulls = []
for null in range(points.GetNumberOfPoints()):
self.nulls.append(points.GetPoint(null))
self.nulls = np.array(self.nulls)
point_data = output.GetPointData()
eigen_values_vtk = []
eigen_values = []
eigen_vectors_vtk = []
eigen_vectors = []
fan_vectors_vtk = []
fan_vectors = []
for dim in range(3):
eigen_values_vtk.append(point_data.GetVectors('eigen_value_{0}'.format(dim)))
eigen_values.append(VN.vtk_to_numpy(eigen_values_vtk[-1]))
eigen_vectors_vtk.append(point_data.GetVectors('eigen_vector_{0}'.format(dim)))
eigen_vectors.append(VN.vtk_to_numpy(eigen_vectors_vtk[-1]))
if dim < 2:
fan_vectors_vtk.append(point_data.GetVectors('fan_vector_{0}'.format(dim)))
fan_vectors.append(VN.vtk_to_numpy(fan_vectors_vtk[-1]))
sign_trace_vtk = point_data.GetVectors('sign_trace')
sign_trace = VN.vtk_to_numpy(sign_trace_vtk)
normals_vtk = point_data.GetVectors('normal')
normals = VN.vtk_to_numpy(normals_vtk)
self.eigen_values = np.swapaxes(np.array(eigen_values), 0, 1)
self.eigen_vectors = np.swapaxes(np.array(eigen_vectors), 0, 1)
self.fan_vectors = np.swapaxes(np.array(fan_vectors), 0, 1)
self.sign_trace = np.array(sign_trace)
self.normals = np.array(normals)
def readVtkFile(self, fileName):
"""
Read VTK file.
:param str filename: Input filename
"""
self.reader = vtk.vtkUnstructuredGridReader()
self.reader.SetFileName(fileName)
self.reader.Update()
self.grid = self.reader.GetOutput()
self.points = self.grid.GetPoints()
def UnstructuredGridReader(self, currentElement):
reader = vtk.vtkUnstructuredGridReader()
try:
reader.SetFileName(os.path.join(self.basedir, currentElement.get('SetFileName')))
except:
self.logger.error(' .. <UnstructuredGridReader> failed to SetFileName')
if 'SetVectorsName' in currentElement.keys():
try:
reader.SetVectorsName( currentElement.get('SetVectorsName') )
except:
self.logger.error(' .. <UnstructuredGridReader> failed to SetVectorsName')
return reader
def getNodes(filename):
# load a vtk file as input
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
points = reader.GetOutput().GetPoints()
if points is None:
return None
# print points
# Get the coordinates of nodes in the mesh
nodes_vtk_array= reader.GetOutput().GetPoints().GetData()
nodes = vtk_to_numpy(nodes_vtk_array)
return nodes
def testContourQuadraticTetra(self):
# Create a reader to load the data (quadratic tetrahedra)
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/quadTetEdgeTest.vtk")
tetContours = vtk.vtkContourFilter()
tetContours.SetInputConnection(reader.GetOutputPort())
tetContours.SetValue(0, 0.5)
aTetContourMapper = vtk.vtkDataSetMapper()
aTetContourMapper.SetInputConnection(tetContours.GetOutputPort())
aTetContourMapper.ScalarVisibilityOff()
aTetMapper = vtk.vtkDataSetMapper()
aTetMapper.SetInputConnection(reader.GetOutputPort())
aTetMapper.ScalarVisibilityOff()
aTetActor = vtk.vtkActor()
aTetActor.SetMapper(aTetMapper)
aTetActor.GetProperty().SetRepresentationToWireframe()
aTetActor.GetProperty().SetAmbient(1.0)
aTetContourActor = vtk.vtkActor()
aTetContourActor.SetMapper(aTetContourMapper)
aTetContourActor.GetProperty().SetAmbient(1.0)
# Create the rendering related stuff.
# Since some of our actors are a single vertex, we need to remove all
# cullers so the single vertex actors will render
ren1 = vtk.vtkRenderer()
ren1.GetCullers().RemoveAllItems()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren1.SetBackground(.1, .2, .3)
renWin.SetSize(400, 250)
# specify properties
ren1.AddActor(aTetActor)
ren1.AddActor(aTetContourActor)
ren1.ResetCamera()
ren1.GetActiveCamera().Dolly(1.5)
ren1.ResetCameraClippingRange()
renWin.Render()
img_file = "contourQuadraticTetra.png"
vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def ReadVtkFile(self, filename):
'''
@param filename: str
@rtype: None
'''
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
try:
reader.Update()
self.setDataSet(reader.GetOutput())
except Exception, e:
print e
# del reader
raise IOError, "Could not read the vtk file! "
def chooseReader(self, file_format, vtk_dataset_type=None):
"""
Return a reader based on file_format and possibly vtk_dataset_type.
@param vtk_dataset_type, None or one of the VTK_DATASET_TYPES
"""
# Handle .ply files.
if file_format == 'ply':
return vtk.vtkPLYReader()
# Handle .vtk files.
if vtk_dataset_type == 'STRUCTURED_GRID':
return vtk.vtkStructuredGridReader()
elif vtk_dataset_type == 'POLYDATA':
return vtk.vtkPolyDataReader()
elif vtk_dataset_type == 'UNSTRUCTURED_GRID':
return vtk.vtkUnstructuredGridReader()
def get_cell_volumes(x_min,x_max,y_min,y_max,z_min,z_max,filename,cell_volume):
reader = vtk.vtkUnstructuredGridReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.SetFileName(filename)
reader.Update()
if ( (x_min<x_max) and (y_min<y_max) and (z_min<z_max) ):
extract = vtk.vtkExtractUnstructuredGrid()
extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max)
extract.SetInput(reader.GetOutput())
extract.MergingOn()
extract.Update()
cell_volume = VN.vtk_to_numpy(extract.GetOutput().GetPointData().GetScalars("cell_volume"))
else:
cell_volume = VN.vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars("cell_volume"))
def get_grid_template(x_min,x_max,y_min,y_max,z_min,z_max,filename,grid): reader = vtk.vtkUnstructuredGridReader() reader.ReadAllScalarsOn() reader.ReadAllVectorsOn() reader.SetFileName(filename) reader.Update() if ( (x_min<x_max) and (y_min<y_max) and (z_min<z_max) ): extract = vtk.vtkExtractUnstructuredGrid() extract.SetExtent(x_min, x_max, y_min, y_max, z_min, z_max) extract.SetInput(reader.GetOutput()) extract.MergingOn() extract.Update() grid.DeepCopy(extract.GetOutput()) else: grid.DeepCopy(reader.GetOutput())
def __init__(self,delta,wing):
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
self.print_counter=0
self.ren = vtk.vtkRenderer()
self.geo_reader = vtk.vtkUnstructuredGridReader()
self.geo_reader.SetFileName(wing)
self.vec_reader = vtk.vtkStructuredPointsReader()
self.vec_reader.SetFileName(delta)
""" This is for drawing the wing,"""
geo_Mapper=vtk.vtkDataSetMapper()
geo_Mapper.SetInputConnection(self.geo_reader.GetOutputPort())
geo_actor = vtk.vtkActor()
geo_actor.SetMapper(geo_Mapper)
self.ren.AddActor(geo_actor)
"""End of adding the wing """
self.ren.AddActor(self.create_stream_line(25,150,0,0.5))
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.2f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(60)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
self.ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
