def tetrahedralize(self, leave_tetra_only=True):
tetra = vtk.vtkDataSetTriangleFilter()
if leave_tetra_only:
tetra.TetrahedraOnlyOn()
tetra.SetInputConnection(self.mesh.GetOutputPort())
tetra.Update()
self.mesh = tetra
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkDataSetTriangleFilter(), 'Processing.',
('vtkDataSet',), ('vtkUnstructuredGrid',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def tetrahedralize_vtk_mesh(vtkdata):
"""
3D cells are converted to tetrahedral meshes, 2D cells to triangles.
Parameters
----------
vtkdata : VTK object
Mesh, scalar, vector and tensor data.
Returns
-------
tetra : VTK object
Mesh, scalar, vector and tensor data.
"""
tetra = vtk.vtkDataSetTriangleFilter()
if vtk_version < 6:
tetra.SetInput(vtkdata)
else:
tetra.SetInputData(vtkdata)
tetra.SetInput(vtkdata)
tetra.Update()
return tetra.GetOutput()
def tetrahedralize_vtk_mesh(vtkdata):
"""
3D cells are converted to tetrahedral meshes, 2D cells to triangles.
Parameters
----------
vtkdata : VTK object
Mesh, scalar, vector and tensor data.
Returns
-------
tetra : VTK object
Mesh, scalar, vector and tensor data.
"""
tetra = vtk.vtkDataSetTriangleFilter()
if vtk_version < 6:
tetra.SetInput(vtkdata)
else:
tetra.SetInputData(vtkdata)
tetra.SetInput(vtkdata)
tetra.Update()
return tetra.GetOutput()
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 computeVolumes(meshVTK,
th,
scalarFieldName='rvot',
path=None,
writeInletOutlet=True,
returnMeshes=False,
**kwargs):
meshVTK.GetPointData().SetActiveScalars(scalarFieldName)
clip = vtk.vtkClipDataSet()
clip.SetInputData(meshVTK)
clip.SetValue(th)
clip.SetInsideOut(kwargs.get('greaterOrEqual', True)) # Get <=
clip.Update()
tetrahedrilize = vtk.vtkDataSetTriangleFilter()
tetrahedrilize.SetInputConnection(clip.GetOutputPort())
tetrahedrilize.Update()
outlet = tetrahedrilize.GetOutput()
clip2 = vtk.vtkClipDataSet()
clip2.SetInputData(meshVTK)
clip2.SetValue(th)
clip2.SetInsideOut(not kwargs.get('greaterOrEqual', True))
clip2.Update()
tetrahedrilize2 = vtk.vtkDataSetTriangleFilter()
tetrahedrilize2.SetInputConnection(clip2.GetOutputPort())
tetrahedrilize2.Update()
inlet = tetrahedrilize2.GetOutput()
if path is not None:
path = path.replace('.1', '')
if writeInletOutlet:
utilities.writeUnstructuredGridVTK(
utilities.appendStringBeforeFileType(
path, kwargs.get('name1', '_inlet')), inlet)
utilities.writeUnstructuredGridVTK(
utilities.appendStringBeforeFileType(
path, kwargs.get('name2', '_outlet')), outlet)
else:
utilities.writeUnstructuredGridVTK(path, inlet)
if not returnMeshes:
return computeVolumeTetrahedralMesh(
inlet), computeVolumeTetrahedralMesh(outlet)
else:
return inlet, outlet
def getVTKActor(self, obj):
self.triFilter = vtk.vtkDataSetTriangleFilter()
self.mapper = vtk.vtkDataSetMapper()
self.actor = vtk.vtkActor()
self.triFilter.SetInput(obj)
self.mapper.SetInput(self.triFilter.GetOutput())
self.actor.SetMapper(self.mapper)
self.ren.AddActor(self.actor)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkDataSetTriangleFilter(),
'Processing.', ('vtkDataSet', ),
('vtkUnstructuredGrid', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def WriteTecplotMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing Tecplot file.')
triangleFilter = vtk.vtkDataSetTriangleFilter()
triangleFilter.SetInputData(self.Mesh)
triangleFilter.Update()
self.Mesh = triangleFilter.GetOutput()
f = open(self.OutputFileName, 'w')
line = "VARIABLES = X,Y,Z"
arrayNames = []
for i in range(self.Mesh.GetPointData().GetNumberOfArrays()):
array = self.Mesh.GetPointData().GetArray(i)
arrayName = array.GetName()
if arrayName == None:
continue
if (arrayName[-1] == '_'):
continue
arrayNames.append(arrayName)
if (array.GetNumberOfComponents() == 1):
line = line + ',' + arrayName
else:
for j in range(array.GetNumberOfComponents()):
line = line + ',' + arrayName + str(j)
line = line + '\n'
f.write(line)
tetraCellIdArray = vtk.vtkIdTypeArray()
tetraCellType = 10
self.Mesh.GetIdsOfCellsOfType(tetraCellType, tetraCellIdArray)
numberOfTetras = tetraCellIdArray.GetNumberOfTuples()
line = "ZONE " + "N=" + str(self.Mesh.GetNumberOfPoints(
)) + ',' + "E=" + str(
numberOfTetras) + ',' + "F=FEPOINT" + ',' + "ET=TETRAHEDRON" + '\n'
f.write(line)
for i in range(self.Mesh.GetNumberOfPoints()):
point = self.Mesh.GetPoint(i)
line = str(point[0]) + ' ' + str(point[1]) + ' ' + str(point[2])
for arrayName in arrayNames:
array = self.Mesh.GetPointData().GetArray(arrayName)
for j in range(array.GetNumberOfComponents()):
line = line + ' ' + str(array.GetComponent(i, j))
line = line + '\n'
f.write(line)
for i in range(numberOfTetras):
cellPointIds = self.Mesh.GetCell(
tetraCellIdArray.GetValue(i)).GetPointIds()
line = ''
for j in range(cellPointIds.GetNumberOfIds()):
if (j > 0):
line = line + ' '
line = line + str(cellPointIds.GetId(j) + 1)
line = line + '\n'
f.write(line)
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInputData(self.Mesh)
if ((vtk.vtkVersion.GetVTKMajorVersion()>=5) and (vtk.vtkVersion.GetVTKMinorVersion()>0)):
tetrahedralizeFilter.SetTetrahedraOnly(self.TetrahedraOnly)
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInputData(self.Mesh)
if ((vtk.vtkVersion.GetVTKMajorVersion() >= 5)
and (vtk.vtkVersion.GetVTKMinorVersion() > 0)):
tetrahedralizeFilter.SetTetrahedraOnly(self.TetrahedraOnly)
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
def WriteTecplotMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing Tecplot file.')
triangleFilter = vtk.vtkDataSetTriangleFilter()
triangleFilter.SetInputData(self.Mesh)
triangleFilter.Update()
self.Mesh = triangleFilter.GetOutput()
f=open(self.OutputFileName, 'w')
line = "VARIABLES = X,Y,Z"
arrayNames = []
for i in range(self.Mesh.GetPointData().GetNumberOfArrays()):
array = self.Mesh.GetPointData().GetArray(i)
arrayName = array.GetName()
if arrayName == None:
continue
if (arrayName[-1]=='_'):
continue
arrayNames.append(arrayName)
if (array.GetNumberOfComponents() == 1):
line = line + ',' + arrayName
else:
for j in range(array.GetNumberOfComponents()):
line = line + ',' + arrayName + str(j)
line = line + '\n'
f.write(line)
tetraCellIdArray = vtk.vtkIdTypeArray()
tetraCellType = 10
self.Mesh.GetIdsOfCellsOfType(tetraCellType,tetraCellIdArray)
numberOfTetras = tetraCellIdArray.GetNumberOfTuples()
line = "ZONE " + "N=" + str(self.Mesh.GetNumberOfPoints()) + ',' + "E=" + str(numberOfTetras) + ',' + "F=FEPOINT" + ',' + "ET=TETRAHEDRON" + '\n'
f.write(line)
for i in range(self.Mesh.GetNumberOfPoints()):
point = self.Mesh.GetPoint(i)
line = str(point[0]) + ' ' + str(point[1]) + ' ' + str(point[2])
for arrayName in arrayNames:
array = self.Mesh.GetPointData().GetArray(arrayName)
for j in range(array.GetNumberOfComponents()):
line = line + ' ' + str(array.GetComponent(i,j))
line = line + '\n'
f.write(line)
for i in range(numberOfTetras):
cellPointIds = self.Mesh.GetCell(tetraCellIdArray.GetValue(i)).GetPointIds()
line = ''
for j in range(cellPointIds.GetNumberOfIds()):
if (j>0):
line = line + ' '
line = line + str(cellPointIds.GetId(j)+1)
line = line + '\n'
f.write(line)
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInput(self.Mesh)
tetrahedralizeFilter.SetTetrahedraOnly(self.TetrahedraOnly)
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInput(self.Mesh)
tetrahedralizeFilter.SetTetrahedraOnly(self.TetrahedraOnly)
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
def triangulate(dataset):
"""
Returns an all triangle mesh. More complex polygons will be broken
down into triangles.
Returns
-------
mesh : vtki.UnstructuredGrid
Mesh containing only triangles.
"""
alg = vtk.vtkDataSetTriangleFilter()
alg.SetInputData(dataset)
alg.Update()
return _get_output(alg)
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInputData(self.Mesh)
tetrahedralizeFilter.TetrahedraOnlyOn()
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
self.Volume = 0.0
cellPoints = vtk.vtkIdList()
for i in xrange(self.Mesh.GetNumberOfCells()):
self.Mesh.GetCellPoints(i,cellPoints)
point0 = self.Mesh.GetPoint(cellPoints.GetId(0))
point1 = self.Mesh.GetPoint(cellPoints.GetId(1))
point2 = self.Mesh.GetPoint(cellPoints.GetId(2))
point3 = self.Mesh.GetPoint(cellPoints.GetId(3))
self.Volume += abs(vtk.vtkTetra.ComputeVolume(point0,point1,point2,point3))
def tetralize(dataset, tetsOnly=True):
"""Tetralize any type of dataset.
If tetsOnly is True will cull all 1D and 2D cells from the output.
Return a TetMesh.
Example:
.. code-block:: python
from vedo import *
ug = loadUnStructuredGrid(datadir+'ugrid.vtk')
tmesh = tetralize(ug)
tmesh.write('ugrid.vtu').show(axes=1)
"""
tt = vtk.vtkDataSetTriangleFilter()
tt.SetInputData(dataset)
tt.SetTetrahedraOnly(tetsOnly)
tt.Update()
m = TetMesh(tt.GetOutput())
return m
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: No input mesh.')
tetrahedralizeFilter = vtk.vtkDataSetTriangleFilter()
tetrahedralizeFilter.SetInputData(self.Mesh)
tetrahedralizeFilter.TetrahedraOnlyOn()
tetrahedralizeFilter.Update()
self.Mesh = tetrahedralizeFilter.GetOutput()
self.Volume = 0.0
cellPoints = vtk.vtkIdList()
for i in range(self.Mesh.GetNumberOfCells()):
self.Mesh.GetCellPoints(i, cellPoints)
point0 = self.Mesh.GetPoint(cellPoints.GetId(0))
point1 = self.Mesh.GetPoint(cellPoints.GetId(1))
point2 = self.Mesh.GetPoint(cellPoints.GetId(2))
point3 = self.Mesh.GetPoint(cellPoints.GetId(3))
self.Volume += abs(
vtk.vtkTetra.ComputeVolume(point0, point1, point2, point3))
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.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()
#
PIECE = 0
NUMBER_OF_PIECES = 8
reader = vtk.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0,63,0,63,1,64)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
reader.SetDataSpacing(1.6,1.6,1.5)
clipper = vtk.vtkImageClip()
clipper.SetInputConnection(reader.GetOutputPort())
clipper.SetOutputWholeExtent(30,36,30,36,30,36)
clipper2 = vtk.vtkImageClip()
clipper2.SetInputConnection(reader.GetOutputPort())
clipper2.SetOutputWholeExtent(30,36,30,36,30,36)
tris = vtk.vtkDataSetTriangleFilter()
tris.SetInputConnection(clipper.GetOutputPort())
tris2 = vtk.vtkDataSetTriangleFilter()
tris2.SetInputConnection(clipper2.GetOutputPort())
geom = vtk.vtkGeometryFilter()
geom.SetInputConnection(tris.GetOutputPort())
pf = vtk.vtkProgrammableFilter()
pf.SetInputConnection(tris2.GetOutputPort())
def remove_ghosts():
input = pf.GetInput()
output = pf.GetOutputDataObject(0)
output.ShallowCopy(input)
output.RemoveGhostCells()
pf.SetExecuteMethod(remove_ghosts)
edges = vtk.vtkExtractEdges()
edges.SetInputConnection(pf.GetOutputPort())
#
PIECE = 0
NUMBER_OF_PIECES = 8
reader = vtk.vtkImageReader()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0,63,0,63,1,64)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
reader.SetDataSpacing(1.6,1.6,1.5)
clipper = vtk.vtkImageClip()
clipper.SetInputConnection(reader.GetOutputPort())
clipper.SetOutputWholeExtent(30,36,30,36,30,36)
clipper2 = vtk.vtkImageClip()
clipper2.SetInputConnection(reader.GetOutputPort())
clipper2.SetOutputWholeExtent(30,36,30,36,30,36)
tris = vtk.vtkDataSetTriangleFilter()
tris.SetInputConnection(clipper.GetOutputPort())
tris2 = vtk.vtkDataSetTriangleFilter()
tris2.SetInputConnection(clipper2.GetOutputPort())
geom = vtk.vtkGeometryFilter()
geom.SetInputConnection(tris.GetOutputPort())
pf = vtk.vtkProgrammableFilter()
pf.SetInputConnection(tris2.GetOutputPort())
def remove_ghosts():
input = pf.GetInput()
output = pf.GetOutputDataObject(0)
output.ShallowCopy(input)
output.RemoveGhostCells()
pf.SetExecuteMethod(remove_ghosts)
edges = vtk.vtkExtractEdges()
edges.SetInputConnection(pf.GetOutputPort())
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
self.PrintLog("Capping surface")
capper = vmtkscripts.vmtkSurfaceCapper()
capper.Surface = self.Surface
capper.Interactive = 0
capper.Method = 'simple'
capper.TriangleOutput = 0
capper.CellEntityIdOffset = 1
capper.Execute()
self.PrintLog("Remeshing surface")
remeshing = vmtkscripts.vmtkSurfaceRemeshing()
remeshing.Surface = capper.Surface
remeshing.CellEntityIdsArrayName = capper.CellEntityIdsArrayName
remeshing.TargetEdgeLength = self.TargetEdgeLength
remeshing.MaxEdgeLength = self.MaxEdgeLength
remeshing.MinEdgeLength = self.MinEdgeLength
remeshing.TargetEdgeLengthFactor = self.TargetEdgeLengthFactor
remeshing.TargetEdgeLengthArrayName = self.TargetEdgeLengthArrayName
remeshing.ElementSizeMode = self.ElementSizeMode
remeshing.Execute()
if self.BoundaryLayer:
projection = vmtkscripts.vmtkSurfaceProjection()
projection.Surface = remeshing.Surface
projection.ReferenceSurface = capper.Surface
projection.Execute()
normals = vmtkscripts.vmtkSurfaceNormals()
normals.Surface = projection.Surface
normals.NormalsArrayName = 'Normals'
normals.Execute()
surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh.Surface = normals.Surface
surfaceToMesh.Execute()
self.PrintLog("Generating boundary layer")
boundaryLayer = vmtkscripts.vmtkBoundaryLayer()
boundaryLayer.Mesh = surfaceToMesh.Mesh
boundaryLayer.WarpVectorsArrayName = 'Normals'
boundaryLayer.NegateWarpVectors = True
boundaryLayer.ThicknessArrayName = self.TargetEdgeLengthArrayName
if self.ElementSizeMode == 'edgelength':
boundaryLayer.ConstantThickness = True
else:
boundaryLayer.ConstantThickness = False
boundaryLayer.IncludeSurfaceCells = 0
boundaryLayer.NumberOfSubLayers = self.NumberOfSubLayers
boundaryLayer.SubLayerRatio = 0.5
boundaryLayer.Thickness = self.BoundaryLayerThicknessFactor * self.TargetEdgeLength
boundaryLayer.ThicknessRatio = self.BoundaryLayerThicknessFactor * self.TargetEdgeLengthFactor
boundaryLayer.MaximumThickness = self.BoundaryLayerThicknessFactor * self.MaxEdgeLength
boundaryLayer.Execute()
cellEntityIdsArray = vtk.vtkIntArray()
cellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
cellEntityIdsArray.SetNumberOfTuples(boundaryLayer.Mesh.GetNumberOfCells())
cellEntityIdsArray.FillComponent(0,0.0)
boundaryLayer.Mesh.GetCellData().AddArray(cellEntityIdsArray)
innerCellEntityIdsArray = vtk.vtkIntArray()
innerCellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
innerCellEntityIdsArray.SetNumberOfTuples(boundaryLayer.InnerSurfaceMesh.GetNumberOfCells())
innerCellEntityIdsArray.FillComponent(0,0.0)
boundaryLayer.InnerSurfaceMesh.GetCellData().AddArray(cellEntityIdsArray)
meshToSurface = vmtkscripts.vmtkMeshToSurface()
meshToSurface.Mesh = boundaryLayer.InnerSurfaceMesh
meshToSurface.Execute()
self.PrintLog("Computing sizing function")
sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction()
sizingFunction.SetInput(meshToSurface.Surface)
sizingFunction.SetSizingFunctionArrayName(self.SizingFunctionArrayName)
sizingFunction.SetScaleFactor(self.VolumeElementScaleFactor)
sizingFunction.Update()
surfaceToMesh2 = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh2.Surface = sizingFunction.GetOutput()
surfaceToMesh2.Execute()
self.PrintLog("Generating volume mesh")
tetgen = vmtkscripts.vmtkTetGen()
tetgen.Mesh = surfaceToMesh2.Mesh
tetgen.GenerateCaps = 0
tetgen.UseSizingFunction = 1
tetgen.SizingFunctionArrayName = self.SizingFunctionArrayName
tetgen.CellEntityIdsArrayName = self.CellEntityIdsArrayName
tetgen.Order = 1
tetgen.Quality = 1
tetgen.PLC = 1
tetgen.NoBoundarySplit = 1
tetgen.RemoveSliver = 1
tetgen.OutputSurfaceElements = 0
tetgen.OutputVolumeElements = 1
tetgen.Execute()
if tetgen.Mesh.GetNumberOfCells() == 0 and surfaceToMesh.Mesh.GetNumberOfCells() > 0:
self.PrintLog('An error occurred during tetrahedralization. Will only output surface mesh and boundary layer.')
appendFilter = vtkvmtk.vtkvmtkAppendFilter()
appendFilter.AddInput(surfaceToMesh.Mesh)
appendFilter.AddInput(boundaryLayer.Mesh)
appendFilter.AddInput(tetgen.Mesh)
appendFilter.Update()
self.Mesh = appendFilter.GetOutput()
else:
self.PrintLog("Computing sizing function")
sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction()
sizingFunction.SetInput(remeshing.Surface)
sizingFunction.SetSizingFunctionArrayName(self.SizingFunctionArrayName)
sizingFunction.SetScaleFactor(self.VolumeElementScaleFactor)
sizingFunction.Update()
self.PrintLog("Converting surface to mesh")
surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh.Surface = sizingFunction.GetOutput()
surfaceToMesh.Execute()
self.PrintLog("Generating volume mesh")
tetgen = vmtkscripts.vmtkTetGen()
tetgen.Mesh = surfaceToMesh.Mesh
tetgen.GenerateCaps = 0
tetgen.UseSizingFunction = 1
tetgen.SizingFunctionArrayName = self.SizingFunctionArrayName
tetgen.CellEntityIdsArrayName = self.CellEntityIdsArrayName
tetgen.Order = 1
tetgen.Quality = 1
tetgen.PLC = 1
tetgen.NoBoundarySplit = 1
tetgen.RemoveSliver = 1
tetgen.OutputSurfaceElements = 1
tetgen.OutputVolumeElements = 1
tetgen.Execute()
self.Mesh = tetgen.Mesh
if self.Mesh.GetNumberOfCells() == 0 and surfaceToMesh.Mesh.GetNumberOfCells() > 0:
self.PrintLog('An error occurred during tetrahedralization. Will only output surface mesh.')
self.Mesh = surfaceToMesh.Mesh
if self.Tetrahedralize:
tetrahedralize = vtk.vtkDataSetTriangleFilter()
tetrahedralize.SetInput(self.Mesh)
tetrahedralize.Update()
self.Mesh = tetrahedralize.GetOutput()
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: no Mesh.')
## if (self.FOVNormal != [0.0, 0.0, 1.0]):
##
## translation = [-self.FOVCenter[0], -self.FOVCenter[1], -self.FOVCenter[2]]
##
## referenceNormal = [0.0, 0.0, 1.0]
## rotationAxis = [0.0, 0.0, 0.0]
## vtk.vtkMath.Normalize(self.FOVNormal)
## vtk.vtkMath.Cross(self.FOVNormal,referenceNormal,rotationAxis)
## angle = self.AngleBetweenNormals(referenceNormal,self.FOVNormal) / vtk.vtkMath.Pi() * 180.0
##
## transform = vtk.vtkTransform()
## transform.PostMultiply()
## transform.Translate(translation)
## transform.RotateWXYZ(angle,rotationAxis)
## transform.Translate(self.FOVCenter)
##
## transformFilter = vtk.vtkTransformFilter()
## transformFilter.SetInput(self.Mesh)
## transformFilter.SetTransform(transform)
## transformFilter.Update()
##
## acquiredMesh = transformFilter.GetOutput()
if (self.KSpaceDimensionality == 3) or not self.SliceModel:
origin = [self.FOVCenter[0] - self.FOV[0]/2.0,
self.FOVCenter[1] - self.FOV[1]/2.0,
self.FOVCenter[2] - self.FOV[2]/2.0]
spacing = [self.FOV[0] / self.MatrixSize[0],
self.FOV[1] / self.MatrixSize[1],
self.FOV[2] / self.MatrixSize[2]]
self.KSpace = self.AcquireKSpace(self.Mesh,origin,spacing)
elif self.KSpaceDimensionality == 2:
kSpaceAppend = vtk.vtkImageAppend()
kSpaceAppend.SetAppendAxis(2)
sliceLocations = []
sliceLocation = self.FOVCenter[2] - self.FOV[2]/2.0
while (sliceLocation < self.FOVCenter[2] + self.FOV[2]/2.0):
sliceLocations.append(sliceLocation)
sliceLocation += self.SliceSpacing
spacing = [self.FOV[0] / self.MatrixSize[0],
self.FOV[1] / self.MatrixSize[1],
self.FOV[2] / self.MatrixSize[2]]
bounds = self.Mesh.GetBounds()
for sliceLocation in sliceLocations:
self.PrintLog("Processing slice at" + float(sliceLocation))
origin = [self.FOVCenter[0] - self.FOV[0]/2.0,
self.FOVCenter[1] - self.FOV[1]/2.0,
sliceLocation]
clipper1 = vtk.vtkClipDataSet()
clipper1.SetInput(self.Mesh)
clipper1.InsideOutOff()
plane1 = vtk.vtkPlane()
plane1.SetNormal(0.0,0.0,1.0)
plane1.SetOrigin(0.0,0.0,sliceLocation - self.SliceThickness / 2.0)
clipper1.SetClipFunction(plane1)
clipper1.Update()
clipper2 = vtk.vtkClipDataSet()
clipper2.SetInput(clipper1.GetOutput())
clipper2.InsideOutOn()
plane2 = vtk.vtkPlane()
plane2.SetNormal(0.0,0.0,1.0)
plane2.SetOrigin(0.0,0.0,sliceLocation + self.SliceThickness / 2.0)
clipper2.SetClipFunction(plane2)
clipper2.Update()
clipper2Bounds = clipper2.GetOutput().GetBounds()
cleaner = vtk.vtkExtractUnstructuredGrid()
cleaner.SetInput(clipper2.GetOutput())
cleaner.ExtentClippingOn()
cleaner.SetExtent(clipper2Bounds[0],clipper2Bounds[1],
clipper2Bounds[2],clipper2Bounds[3],
sliceLocation-self.SliceThickness/2.0,sliceLocation+self.SliceThickness/2.0)
cleaner.Update()
tetraFilter = vtk.vtkDataSetTriangleFilter()
tetraFilter.SetInput(cleaner.GetOutput())
tetraFilter.Update()
sliceMesh = tetraFilter.GetOutput()
self.PrintLog("Number of integration elements:" + int(sliceMesh.GetNumberOfCells()))
sliceKSpace = self.AcquireKSpace(sliceMesh,origin,spacing)
kSpaceAppend.AddInput(sliceKSpace)
kSpaceAppend.Update()
self.KSpace = self.ComputeKSpaceOperation(kSpaceAppend.GetOutput())
pd2cd.Update()
timer.StopTimer()
time = timer.GetElapsedTime()
print("Point Data To Cell Data (Structured): {0}".format(time))
# Convert to unstructured grid using threshold hack (side effect is
# conversion to vtkUnstructuredGrid)
extract = vtk.vtkThreshold()
extract.SetInputConnection(ele.GetOutputPort())
extract.SetThresholdFunction(vtk.vtkThreshold.THRESHOLD_BETWEEN)
extract.SetLowerThreshold(-10000.0)
extract.SetUpperThreshold(10000.0)
extract.Update()
# Create tests
tetras = vtk.vtkDataSetTriangleFilter()
tetras.SetInputConnection(extract.GetOutputPort())
if genHexes:
output = extract.GetOutput()
print("Processing {0} hexes".format(
extract.GetOutput().GetNumberOfCells()))
else:
tetras.Update()
output = tetras.GetOutput()
print("Processing {0} tets".format(tetras.GetOutput().GetNumberOfCells()))
# Now process the data
pd2cd2 = vtk.vtkPointDataToCellData()
pd2cd2.SetInputData(output)
pd2cd2.SetCategoricalData(catData)
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() math = vtk.vtkMath() math.RandomSeed(22) pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.Update() output = pl3d.GetOutput().GetBlock(0) dst = vtk.vtkDataSetTriangleFilter() dst.SetInputData(output) extract = vtk.vtkExtractUnstructuredGridPiece() extract.SetInputConnection(dst.GetOutputPort()) cf = vtk.vtkContourFilter() cf.SetInputConnection(extract.GetOutputPort()) cf.SetValue(0, 0.24) pdn = vtk.vtkPolyDataNormals() pdn.SetInputConnection(cf.GetOutputPort()) ps = vtk.vtkPieceScalars() ps.SetInputConnection(pdn.GetOutputPort())
def GetSource(dataType):
s = vtk.vtkRTAnalyticSource()
# Fake serial source
if rank == 0:
s.Update()
if dataType == 'ImageData':
return s.GetOutput()
elif dataType == 'UnstructuredGrid':
dst = vtk.vtkDataSetTriangleFilter()
dst.SetInputData(s.GetOutput())
dst.Update()
return dst.GetOutput()
elif dataType == 'RectilinearGrid':
input = s.GetOutput()
rg = vtk.vtkRectilinearGrid()
rg.SetExtent(input.GetExtent())
dims = input.GetDimensions()
spacing = input.GetSpacing()
x = vtk.vtkFloatArray()
x.SetNumberOfTuples(dims[0])
for i in range(dims[0]):
x.SetValue(i, spacing[0]*i)
y = vtk.vtkFloatArray()
y.SetNumberOfTuples(dims[1])
for i in range(dims[1]):
y.SetValue(i, spacing[1]*i)
z = vtk.vtkFloatArray()
z.SetNumberOfTuples(dims[2])
for i in range(dims[2]):
z.SetValue(i, spacing[2]*i)
rg.SetXCoordinates(x)
rg.SetYCoordinates(y)
rg.SetZCoordinates(z)
rg.GetPointData().ShallowCopy(input.GetPointData())
return rg
elif dataType == 'StructuredGrid':
input = s.GetOutput()
sg = vtk.vtkStructuredGrid()
sg.SetExtent(input.GetExtent())
pts = vtk.vtkPoints()
sg.SetPoints(pts)
npts = input.GetNumberOfPoints()
for i in xrange(npts):
pts.InsertNextPoint(input.GetPoint(i))
sg.GetPointData().ShallowCopy(input.GetPointData())
return sg
polydatawriter.SetInput(polydata) polydatawriter.Update() DiffusingTipLength = 100. DiffusingTipRadius = 10. vtkCylinder = vtk.vtkCylinderSource() vtkCylinder.SetHeight(DiffusingTipLength ); vtkCylinder.SetRadius(DiffusingTipRadius ); vtkCylinder.SetCenter(0.0, 0.0, 0.0); vtkCylinder.SetResolution(16); vtkCylinder.Update() # create 3d model trianglefilter = vtk.vtkDataSetTriangleFilter() trianglefilter.SetInput(vtkCylinder.GetOutput() ) ## cylinderdata = vtkCylinder.GetOutput() ## numpoints = cylinderdata.GetNumberOfPoints() ## ## # create 3d surface ## # The points to be triangulated are generated randomly in the unit ## # cube located at the origin. The points are then associated with a ## # vtkPolyData. ## math = vtk.vtkMath() ## points = vtk.vtkPoints() ## pointcounter=0 ## for iii in range(numpoints ): ## (xx,yy,zz) = cylinderdata.GetPoint(iii) ## for jjj in range(1,6):
def Execute(self):
if self.Mesh == None:
self.PrintError('Error: no Mesh.')
## if (self.FOVNormal != [0.0, 0.0, 1.0]):
##
## translation = [-self.FOVCenter[0], -self.FOVCenter[1], -self.FOVCenter[2]]
##
## referenceNormal = [0.0, 0.0, 1.0]
## rotationAxis = [0.0, 0.0, 0.0]
## vtk.vtkMath.Normalize(self.FOVNormal)
## vtk.vtkMath.Cross(self.FOVNormal,referenceNormal,rotationAxis)
## angle = self.AngleBetweenNormals(referenceNormal,self.FOVNormal) / vtk.vtkMath.Pi() * 180.0
##
## transform = vtk.vtkTransform()
## transform.PostMultiply()
## transform.Translate(translation)
## transform.RotateWXYZ(angle,rotationAxis)
## transform.Translate(self.FOVCenter)
##
## transformFilter = vtk.vtkTransformFilter()
## transformFilter.SetInput(self.Mesh)
## transformFilter.SetTransform(transform)
## transformFilter.Update()
##
## acquiredMesh = transformFilter.GetOutput()
if (self.KSpaceDimensionality == 3) or not self.SliceModel:
origin = [
self.FOVCenter[0] - self.FOV[0] / 2.0,
self.FOVCenter[1] - self.FOV[1] / 2.0,
self.FOVCenter[2] - self.FOV[2] / 2.0
]
spacing = [
self.FOV[0] / self.MatrixSize[0],
self.FOV[1] / self.MatrixSize[1],
self.FOV[2] / self.MatrixSize[2]
]
self.KSpace = self.AcquireKSpace(self.Mesh, origin, spacing)
elif self.KSpaceDimensionality == 2:
kSpaceAppend = vtk.vtkImageAppend()
kSpaceAppend.SetAppendAxis(2)
sliceLocations = []
sliceLocation = self.FOVCenter[2] - self.FOV[2] / 2.0
while (sliceLocation < self.FOVCenter[2] + self.FOV[2] / 2.0):
sliceLocations.append(sliceLocation)
sliceLocation += self.SliceSpacing
spacing = [
self.FOV[0] / self.MatrixSize[0],
self.FOV[1] / self.MatrixSize[1],
self.FOV[2] / self.MatrixSize[2]
]
bounds = self.Mesh.GetBounds()
for sliceLocation in sliceLocations:
self.PrintLog("Processing slice at" + float(sliceLocation))
origin = [
self.FOVCenter[0] - self.FOV[0] / 2.0,
self.FOVCenter[1] - self.FOV[1] / 2.0, sliceLocation
]
clipper1 = vtk.vtkClipDataSet()
clipper1.SetInput(self.Mesh)
clipper1.InsideOutOff()
plane1 = vtk.vtkPlane()
plane1.SetNormal(0.0, 0.0, 1.0)
plane1.SetOrigin(0.0, 0.0,
sliceLocation - self.SliceThickness / 2.0)
clipper1.SetClipFunction(plane1)
clipper1.Update()
clipper2 = vtk.vtkClipDataSet()
clipper2.SetInput(clipper1.GetOutput())
clipper2.InsideOutOn()
plane2 = vtk.vtkPlane()
plane2.SetNormal(0.0, 0.0, 1.0)
plane2.SetOrigin(0.0, 0.0,
sliceLocation + self.SliceThickness / 2.0)
clipper2.SetClipFunction(plane2)
clipper2.Update()
clipper2Bounds = clipper2.GetOutput().GetBounds()
cleaner = vtk.vtkExtractUnstructuredGrid()
cleaner.SetInput(clipper2.GetOutput())
cleaner.ExtentClippingOn()
cleaner.SetExtent(clipper2Bounds[0], clipper2Bounds[1],
clipper2Bounds[2], clipper2Bounds[3],
sliceLocation - self.SliceThickness / 2.0,
sliceLocation + self.SliceThickness / 2.0)
cleaner.Update()
tetraFilter = vtk.vtkDataSetTriangleFilter()
tetraFilter.SetInput(cleaner.GetOutput())
tetraFilter.Update()
sliceMesh = tetraFilter.GetOutput()
self.PrintLog("Number of integration elements:" +
int(sliceMesh.GetNumberOfCells()))
sliceKSpace = self.AcquireKSpace(sliceMesh, origin, spacing)
kSpaceAppend.AddInput(sliceKSpace)
kSpaceAppend.Update()
self.KSpace = self.ComputeKSpaceOperation(kSpaceAppend.GetOutput())
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No input surface.')
wallEntityOffset = 1
if self.SkipCapping:
self.PrintLog("Not capping surface")
surface = self.Surface
else:
self.PrintLog("Capping surface")
capper = vmtkscripts.vmtkSurfaceCapper()
capper.Surface = self.Surface
capper.Interactive = 0
capper.Method = self.CappingMethod
capper.TriangleOutput = 0
capper.CellEntityIdOffset = 1
capper.CellEntityIdOffset = wallEntityOffset
capper.Execute()
surface = capper.Surface
if self.SkipRemeshing:
remeshedSurface = surface
else:
self.PrintLog("Remeshing surface")
remeshing = vmtkscripts.vmtkSurfaceRemeshing()
remeshing.Surface = surface
remeshing.CellEntityIdsArrayName = self.CellEntityIdsArrayName
remeshing.TargetEdgeLength = self.TargetEdgeLength
remeshing.MaxEdgeLength = self.MaxEdgeLength
remeshing.MinEdgeLength = self.MinEdgeLength
remeshing.TargetEdgeLengthFactor = self.TargetEdgeLengthFactor
remeshing.TargetEdgeLengthArrayName = self.TargetEdgeLengthArrayName
remeshing.ElementSizeMode = self.ElementSizeMode
if self.RemeshCapsOnly:
remeshing.ExcludeEntityIds = [wallEntityOffset]
remeshing.Execute()
remeshedSurface = remeshing.Surface
if self.BoundaryLayer:
projection = vmtkscripts.vmtkSurfaceProjection()
projection.Surface = remeshedSurface
projection.ReferenceSurface = surface
projection.Execute()
normals = vmtkscripts.vmtkSurfaceNormals()
normals.Surface = projection.Surface
normals.NormalsArrayName = 'Normals'
normals.Execute()
surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh.Surface = normals.Surface
surfaceToMesh.Execute()
self.PrintLog("Generating boundary layer")
boundaryLayer = vmtkscripts.vmtkBoundaryLayer()
boundaryLayer.Mesh = surfaceToMesh.Mesh
boundaryLayer.WarpVectorsArrayName = 'Normals'
boundaryLayer.NegateWarpVectors = True
boundaryLayer.ThicknessArrayName = self.TargetEdgeLengthArrayName
if self.ElementSizeMode == 'edgelength':
boundaryLayer.ConstantThickness = True
else:
boundaryLayer.ConstantThickness = False
boundaryLayer.IncludeSurfaceCells = 0
boundaryLayer.NumberOfSubLayers = self.NumberOfSubLayers
boundaryLayer.SubLayerRatio = 0.5
boundaryLayer.Thickness = self.BoundaryLayerThicknessFactor * self.TargetEdgeLength
boundaryLayer.ThicknessRatio = self.BoundaryLayerThicknessFactor * self.TargetEdgeLengthFactor
boundaryLayer.MaximumThickness = self.BoundaryLayerThicknessFactor * self.MaxEdgeLength
boundaryLayer.Execute()
cellEntityIdsArray = vtk.vtkIntArray()
cellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
cellEntityIdsArray.SetNumberOfTuples(
boundaryLayer.Mesh.GetNumberOfCells())
cellEntityIdsArray.FillComponent(0, 0.0)
boundaryLayer.Mesh.GetCellData().AddArray(cellEntityIdsArray)
innerCellEntityIdsArray = vtk.vtkIntArray()
innerCellEntityIdsArray.SetName(self.CellEntityIdsArrayName)
innerCellEntityIdsArray.SetNumberOfTuples(
boundaryLayer.InnerSurfaceMesh.GetNumberOfCells())
innerCellEntityIdsArray.FillComponent(0, 0.0)
boundaryLayer.InnerSurfaceMesh.GetCellData().AddArray(
cellEntityIdsArray)
meshToSurface = vmtkscripts.vmtkMeshToSurface()
meshToSurface.Mesh = boundaryLayer.InnerSurfaceMesh
meshToSurface.Execute()
self.PrintLog("Computing sizing function")
sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction()
sizingFunction.SetInput(meshToSurface.Surface)
sizingFunction.SetSizingFunctionArrayName(
self.SizingFunctionArrayName)
sizingFunction.SetScaleFactor(self.VolumeElementScaleFactor)
sizingFunction.Update()
surfaceToMesh2 = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh2.Surface = sizingFunction.GetOutput()
surfaceToMesh2.Execute()
self.PrintLog("Generating volume mesh")
tetgen = vmtkscripts.vmtkTetGen()
tetgen.Mesh = surfaceToMesh2.Mesh
tetgen.GenerateCaps = 0
tetgen.UseSizingFunction = 1
tetgen.SizingFunctionArrayName = self.SizingFunctionArrayName
tetgen.CellEntityIdsArrayName = self.CellEntityIdsArrayName
tetgen.Order = 1
tetgen.Quality = 1
tetgen.PLC = 1
tetgen.NoBoundarySplit = 1
tetgen.RemoveSliver = 1
tetgen.OutputSurfaceElements = 0
tetgen.OutputVolumeElements = 1
tetgen.Execute()
if tetgen.Mesh.GetNumberOfCells(
) == 0 and surfaceToMesh.Mesh.GetNumberOfCells() > 0:
self.PrintLog(
'An error occurred during tetrahedralization. Will only output surface mesh and boundary layer.'
)
appendFilter = vtkvmtk.vtkvmtkAppendFilter()
appendFilter.AddInput(surfaceToMesh.Mesh)
appendFilter.AddInput(boundaryLayer.Mesh)
appendFilter.AddInput(tetgen.Mesh)
appendFilter.Update()
self.Mesh = appendFilter.GetOutput()
else:
self.PrintLog("Computing sizing function")
sizingFunction = vtkvmtk.vtkvmtkPolyDataSizingFunction()
sizingFunction.SetInput(remeshedSurface)
sizingFunction.SetSizingFunctionArrayName(
self.SizingFunctionArrayName)
sizingFunction.SetScaleFactor(self.VolumeElementScaleFactor)
sizingFunction.Update()
self.PrintLog("Converting surface to mesh")
surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh()
surfaceToMesh.Surface = sizingFunction.GetOutput()
surfaceToMesh.Execute()
self.PrintLog("Generating volume mesh")
tetgen = vmtkscripts.vmtkTetGen()
tetgen.Mesh = surfaceToMesh.Mesh
tetgen.GenerateCaps = 0
tetgen.UseSizingFunction = 1
tetgen.SizingFunctionArrayName = self.SizingFunctionArrayName
tetgen.CellEntityIdsArrayName = self.CellEntityIdsArrayName
tetgen.Order = 1
tetgen.Quality = 1
tetgen.PLC = 1
tetgen.NoBoundarySplit = 1
tetgen.RemoveSliver = 1
tetgen.OutputSurfaceElements = 1
tetgen.OutputVolumeElements = 1
tetgen.Execute()
self.Mesh = tetgen.Mesh
if self.Mesh.GetNumberOfCells(
) == 0 and surfaceToMesh.Mesh.GetNumberOfCells() > 0:
self.PrintLog(
'An error occurred during tetrahedralization. Will only output surface mesh.'
)
self.Mesh = surfaceToMesh.Mesh
if self.Tetrahedralize:
tetrahedralize = vtk.vtkDataSetTriangleFilter()
tetrahedralize.SetInput(self.Mesh)
tetrahedralize.Update()
self.Mesh = tetrahedralize.GetOutput()
self.RemeshedSurface = remeshedSurface
polydatawriter.SetInput(polydata)
polydatawriter.Update()
DiffusingTipLength = 100.
DiffusingTipRadius = 10.
vtkCylinder = vtk.vtkCylinderSource()
vtkCylinder.SetHeight(DiffusingTipLength)
vtkCylinder.SetRadius(DiffusingTipRadius)
vtkCylinder.SetCenter(0.0, 0.0, 0.0)
vtkCylinder.SetResolution(16)
vtkCylinder.Update()
# create 3d model
trianglefilter = vtk.vtkDataSetTriangleFilter()
trianglefilter.SetInput(vtkCylinder.GetOutput())
## cylinderdata = vtkCylinder.GetOutput()
## numpoints = cylinderdata.GetNumberOfPoints()
##
## # create 3d surface
## # The points to be triangulated are generated randomly in the unit
## # cube located at the origin. The points are then associated with a
## # vtkPolyData.
## math = vtk.vtkMath()
## points = vtk.vtkPoints()
## pointcounter=0
## for iii in range(numpoints ):
## (xx,yy,zz) = cylinderdata.GetPoint(iii)
## for jjj in range(1,6):
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() math = vtk.vtkMath() math.RandomSeed(22) pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.Update() output = pl3d.GetOutput().GetBlock(0) dst = vtk.vtkDataSetTriangleFilter() dst.SetInputData(output) extract = vtk.vtkExtractUnstructuredGridPiece() extract.SetInputConnection(dst.GetOutputPort()) cf = vtk.vtkContourFilter() cf.SetInputConnection(extract.GetOutputPort()) cf.SetValue(0, 0.24) pdn = vtk.vtkPolyDataNormals() pdn.SetInputConnection(cf.GetOutputPort()) ps = vtk.vtkPieceScalars() ps.SetInputConnection(pdn.GetOutputPort())
def __init__(self, parent=None):
super(VTK_Widget1, self).__init__(parent)
self.source_is_connected = False
# vtk to point data
self.c2p = vtk.vtkCellDataToPointData()
self.opacityTransferFunction = vtk.vtkPiecewiseFunction()
self.colorTransferFunction = vtk.vtkColorTransferFunction()
# create a volume property for describing how the data will look
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.colorTransferFunction)
self.volumeProperty.SetScalarOpacity(self.opacityTransferFunction)
self.volumeProperty.ShadeOn()
self.volumeProperty.SetInterpolationTypeToLinear()
# convert to unstructured grid volume
self.triangleFilter = vtk.vtkDataSetTriangleFilter()
self.triangleFilter.TetrahedraOnlyOn()
self.triangleFilter.SetInputConnection(self.c2p.GetOutputPort())
# create a ray cast mapper
self.compositeFunction = vtk.vtkUnstructuredGridBunykRayCastFunction()
self.volumeMapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
self.volumeMapper.SetRayCastFunction(self.compositeFunction)
self.volumeMapper.SetInputConnection(self.triangleFilter.GetOutputPort())
# create a volume
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumeMapper)
self.volume.SetProperty(self.volumeProperty)
self.volume.VisibilityOff()
# create the VTK widget for rendering
self.vtkw=QVTKRenderWindowInteractor(self)
self.ren = vtk.vtkRenderer()
self.vtkw.GetRenderWindow().AddRenderer(self.ren)
self.ren.AddVolume(self.volume)
self.alphaSlider = QSlider(Qt.Horizontal)
self.alphaSlider.setValue(50)
self.alphaSlider.setRange(0,100)
self.alphaSlider.setTickPosition(QSlider.NoTicks)
self.connect(self.alphaSlider,SIGNAL("valueChanged(int)"),self.AdjustAlpha)
self.alphaLabel = QLabel("alpha: ")
# layout manager
self.layout = QVBoxLayout()
self.layout2 = QHBoxLayout()
self.layout2.addWidget(self.alphaLabel)
self.layout2.addWidget(self.alphaSlider)
self.layout.addWidget(self.vtkw)
self.layout.addSpacing(34)
self.layout.addLayout(self.layout2)
self.setLayout(self.layout)
# initialize the interactor
self.vtkw.Initialize()
self.vtkw.Start()
def GetSource(dataType):
s = vtk.vtkRTAnalyticSource()
if dataType == 'ImageData':
return s
elif dataType == 'UnstructuredGrid':
dst = vtk.vtkDataSetTriangleFilter()
dst.SetInputConnection(s.GetOutputPort())
return dst
elif dataType == 'RectilinearGrid':
s.Update()
input = s.GetOutput()
rg = vtk.vtkRectilinearGrid()
rg.SetExtent(input.GetExtent())
dims = input.GetDimensions()
spacing = input.GetSpacing()
x = vtk.vtkFloatArray()
x.SetNumberOfTuples(dims[0])
for i in range(dims[0]):
x.SetValue(i, spacing[0] * i)
y = vtk.vtkFloatArray()
y.SetNumberOfTuples(dims[1])
for i in range(dims[1]):
y.SetValue(i, spacing[1] * i)
z = vtk.vtkFloatArray()
z.SetNumberOfTuples(dims[2])
for i in range(dims[2]):
z.SetValue(i, spacing[2] * i)
rg.SetXCoordinates(x)
rg.SetYCoordinates(y)
rg.SetZCoordinates(z)
rg.GetPointData().ShallowCopy(input.GetPointData())
pf.SetInputData(rg)
return pf
elif dataType == 'StructuredGrid':
s.Update()
input = s.GetOutput()
sg = vtk.vtkStructuredGrid()
sg.SetExtent(input.GetExtent())
pts = vtk.vtkPoints()
sg.SetPoints(pts)
npts = input.GetNumberOfPoints()
for i in range(npts):
pts.InsertNextPoint(input.GetPoint(i))
sg.GetPointData().ShallowCopy(input.GetPointData())
pf.SetInputData(sg)
return pf
def GetSource(dataType):
s = vtk.vtkRTAnalyticSource()
if dataType == 'ImageData':
return s
elif dataType == 'UnstructuredGrid':
dst = vtk.vtkDataSetTriangleFilter()
dst.SetInputConnection(s.GetOutputPort())
return dst
elif dataType == 'RectilinearGrid':
s.Update()
input = s.GetOutput()
rg = vtk.vtkRectilinearGrid()
rg.SetExtent(input.GetExtent())
dims = input.GetDimensions()
spacing = input.GetSpacing()
x = vtk.vtkFloatArray()
x.SetNumberOfTuples(dims[0])
for i in range(dims[0]):
x.SetValue(i, spacing[0]*i)
y = vtk.vtkFloatArray()
y.SetNumberOfTuples(dims[1])
for i in range(dims[1]):
y.SetValue(i, spacing[1]*i)
z = vtk.vtkFloatArray()
z.SetNumberOfTuples(dims[2])
for i in range(dims[2]):
z.SetValue(i, spacing[2]*i)
rg.SetXCoordinates(x)
rg.SetYCoordinates(y)
rg.SetZCoordinates(z)
rg.GetPointData().ShallowCopy(input.GetPointData())
pf.SetInputData(rg)
return pf
elif dataType == 'StructuredGrid':
s.Update()
input = s.GetOutput()
sg = vtk.vtkStructuredGrid()
sg.SetExtent(input.GetExtent())
pts = vtk.vtkPoints()
sg.SetPoints(pts)
npts = input.GetNumberOfPoints()
for i in range(npts):
pts.InsertNextPoint(input.GetPoint(i))
sg.GetPointData().ShallowCopy(input.GetPointData())
pf.SetInputData(sg)
return pf
elif dataType == 'Table':
s.Update()
input = s.GetOutput()
table = vtk.vtkTable()
RTData = input.GetPointData().GetArray(0)
nbTuples = RTData.GetNumberOfTuples()
array = vtk.vtkFloatArray()
array.SetName("RTData")
array.SetNumberOfTuples(nbTuples)
for i in range(0, nbTuples):
array.SetTuple1(i, float(RTData.GetTuple1(i)))
table.AddColumn(array)
pf.SetInputData(table)
return pf
def __init__(
self,
inputobj=None,
c=('r', 'y', 'lg', 'lb', 'b'), #('b','lb','lg','y','r')
alpha=(0.5, 1),
alphaUnit=1,
mapper='tetra',
):
BaseGrid.__init__(self)
self.useArray = 0
inputtype = str(type(inputobj))
#printc('TetMesh inputtype', inputtype)
###################
if inputobj is None:
self._data = vtk.vtkUnstructuredGrid()
elif isinstance(inputobj, vtk.vtkUnstructuredGrid):
self._data = inputobj
elif isinstance(inputobj, vtk.vtkRectilinearGrid):
r2t = vtk.vtkRectilinearGridToTetrahedra()
r2t.SetInputData(inputobj)
r2t.RememberVoxelIdOn()
r2t.SetTetraPerCellTo6()
r2t.Update()
self._data = r2t.GetOutput()
elif isinstance(inputobj, vtk.vtkDataSet):
r2t = vtk.vtkDataSetTriangleFilter()
r2t.SetInputData(inputobj)
#r2t.TetrahedraOnlyOn()
r2t.Update()
self._data = r2t.GetOutput()
elif isinstance(inputobj, str):
from vedo.io import download, loadUnStructuredGrid
if "https://" in inputobj:
inputobj = download(inputobj, verbose=False)
ug = loadUnStructuredGrid(inputobj)
tt = vtk.vtkDataSetTriangleFilter()
tt.SetInputData(ug)
tt.SetTetrahedraOnly(True)
tt.Update()
self._data = tt.GetOutput()
elif utils.isSequence(inputobj):
# if "ndarray" not in inputtype:
# inputobj = np.array(inputobj)
self._data = self._buildtetugrid(inputobj[0], inputobj[1])
###################
if 'tetra' in mapper:
self._mapper = vtk.vtkProjectedTetrahedraMapper()
elif 'ray' in mapper:
self._mapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
elif 'zs' in mapper:
self._mapper = vtk.vtkUnstructuredGridVolumeZSweepMapper()
elif isinstance(mapper, vtk.vtkMapper):
self._mapper = mapper
else:
printc('Unknown mapper type', [mapper], c='r')
raise RuntimeError()
self._mapper.SetInputData(self._data)
self.SetMapper(self._mapper)
self.color(c).alpha(alpha)
if alphaUnit:
self.GetProperty().SetScalarOpacityUnitDistance(alphaUnit)
# remember stuff:
self._color = c
self._alpha = alpha
self._alphaUnit = alphaUnit
def __init__(
self,
inputobj=None,
c=('r', 'y', 'lg', 'lb', 'b'), #('b','lb','lg','y','r')
alpha=(0.5, 1),
alphaUnit=1,
mapper='tetra',
):
vtk.vtkVolume.__init__(self)
ActorBase.__init__(self)
self._ugrid = None
self.useCells = True
self.useArray = 0
inputtype = str(type(inputobj))
#printc('TetMesh inputtype', inputtype)
###################
if inputobj is None:
self._ugrid = vtk.vtkUnstructuredGrid()
elif isinstance(inputobj, vtk.vtkUnstructuredGrid):
self._ugrid = inputobj
elif isinstance(inputobj, vtk.vtkRectilinearGrid):
r2t = vtk.vtkRectilinearGridToTetrahedra()
r2t.SetInputData(inputobj)
r2t.RememberVoxelIdOn()
r2t.SetTetraPerCellTo6()
r2t.Update()
self._ugrid = r2t.GetOutput()
elif isinstance(inputobj, vtk.vtkDataSet):
r2t = vtk.vtkDataSetTriangleFilter()
r2t.SetInputData(inputobj)
#r2t.TetrahedraOnlyOn()
r2t.Update()
self._ugrid = r2t.GetOutput()
elif isinstance(inputobj, str):
from vtkplotter.vtkio import loadUnStructuredGrid
self._ugrid = loadUnStructuredGrid(inputobj)
elif utils.isSequence(inputobj):
if "ndarray" not in inputtype:
inputobj = np.array(inputobj)
self._ugrid = self._buildugrid(inputobj[0], inputobj[1])
###################
if 'tetra' in mapper:
self._mapper = vtk.vtkProjectedTetrahedraMapper()
elif 'ray' in mapper:
self._mapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
elif 'zs' in mapper:
self._mapper = vtk.vtkUnstructuredGridVolumeZSweepMapper()
elif isinstance(mapper, vtk.vtkMapper):
self._mapper = mapper
else:
printc('Unknown mapper type', [mapper], c=1)
return
self._mapper.SetInputData(self._ugrid)
self.SetMapper(self._mapper)
self.color(c).alpha(alpha)
if alphaUnit:
self.GetProperty().SetScalarOpacityUnitDistance(alphaUnit)
# remember stuff:
self._color = c
self._alpha = alpha
self._alphaUnit = alphaUnit
