def cutWithPlane(self, origin=(0, 0, 0), normal=(1, 0, 0)):
"""
Cut the mesh with the plane defined by a point and a normal.
:param origin: the cutting plane goes through this point
:param normal: normal of the cutting plane
"""
strn = str(normal)
if strn == "x": normal = (1, 0, 0)
elif strn == "y": normal = (0, 1, 0)
elif strn == "z": normal = (0, 0, 1)
elif strn == "-x": normal = (-1, 0, 0)
elif strn == "-y": normal = (0, -1, 0)
elif strn == "-z": normal = (0, 0, -1)
plane = vtk.vtkPlane()
plane.SetOrigin(origin)
plane.SetNormal(normal)
clipper = vtk.vtkClipDataSet()
clipper.SetInputData(self._ugrid)
clipper.SetClipFunction(plane)
clipper.GenerateClipScalarsOff()
clipper.GenerateClippedOutputOff()
clipper.SetValue(0)
clipper.Update()
cout = clipper.GetOutput()
return self._update(cout)
def makePlaneClipper(vtkObj,plane): """Makes a plane and clipper """ clipper = vtk.vtkClipDataSet() clipper.SetInputConnection(vtkObj.GetProducerPort()) clipper.SetClipFunction(plane) clipper.InsideOutOff() return clipper
def ClipMRIWithCylinder(mri_data,cylinderTransformed):
implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
implicitPolyDataDistance.SetInput(cylinderTransformed)
mri_data_copy=mri_data
# Create an array to hold distance information
signedDistances = vtk.vtkFloatArray()
signedDistances.SetNumberOfComponents(1)
signedDistances.SetName("SignedDistances")
# Evaluate the signed distance function at all of the grid points
for pointId in range(mri_data.GetNumberOfPoints()):
p = mri_data.GetPoint(pointId)
signedDistance = implicitPolyDataDistance.EvaluateFunction(p)
signedDistances.InsertNextValue(signedDistance)
# add the SignedDistances to the grid
mriDistanceData=np.zeros([int(mri_data.GetNumberOfPoints()),1])
for i in range(mri_data.GetNumberOfPoints()):
mriDist=signedDistances.GetTuple(i)[0]
mriDistanceData[i]=mriDist
mriDistVtk=vtk.vtkDoubleArray()
mriDistVtk.SetArray(mriDistanceData,mri_data.GetNumberOfPoints(),1)
mri_data_copy.GetPointData().SetScalars(mriDistVtk)
clipper = vtk.vtkClipDataSet()
clipper.SetInputData(mri_data_copy)
clipper.InsideOutOn()
clipper.SetValue(0.0)
clipper.Update()
return clipper
def clip(inp, origin, normal, inside_out=False, take_cell=False):
"""
VTK operation: clip. A vtkGeometryFilter is used to convert the
resulted vtkUnstructuredMesh object into a vtkPolyData object.
@param inp: input VTK object.
@type inp: vtk.vtkobject
@param origin: a 3-tuple for cut origin.
@type origin: tuple
@param normal: a 3-tuple for cut normal.
@type normal: tuple
@keyword inside_out: make inside out. Default False.
@type inside_out: bool
@keyword take_cell: treat the input VTK object with values on cells.
Default False.
@type: take_cell: bool
@return: output VTK object.
@rtype: vtk.vtkobject
"""
import vtk
pne = vtk.vtkPlane()
pne.SetOrigin(origin)
pne.SetNormal(normal)
clip = vtk.vtkClipDataSet()
if take_cell:
clip.SetInput(inp)
else:
clip.SetInputConnection(inp.GetOutputPort())
clip.SetClipFunction(pne)
if inside_out:
clip.InsideOutOn()
parison = vtk.vtkGeometryFilter()
parison.SetInputConnection(clip.GetOutputPort())
return parison
def clip(dataset, normal='x', origin=None, invert=True):
"""
Clip a dataset by a plane by specifying the origin and normal. If no
parameters are given the clip will occur in the center of that dataset
Parameters
----------
normal : tuple(float) or str
Length 3 tuple for the normal vector direction. Can also be
specified as a string conventional direction such as ``'x'`` for
``(1,0,0)`` or ``'-x'`` for ``(-1,0,0)``, etc.
origin : tuple(float)
The center ``(x,y,z)`` coordinate of the plane on which the clip
occurs
invert : bool
Flag on whether to flip/invert the clip
"""
if isinstance(normal, str):
normal = NORMALS[normal.lower()]
# find center of data if origin not specified
if origin is None:
origin = dataset.center
# create the plane for clipping
plane = _generate_plane(normal, origin)
# run the clip
alg = vtk.vtkClipDataSet()
alg.SetInputDataObject(dataset) # Use the grid as the data we desire to cut
alg.SetClipFunction(plane) # the the cutter to use the plane we made
alg.SetInsideOut(invert) # invert the clip if needed
alg.Update() # Perfrom the Cut
return _get_output(alg)
def cutPolyData(dataSet, **kwargs):
# Read options
pt = kwargs.get('point')
normal = kwargs.get('normal')
delta = kwargs.get('maxDist')
if pt == None:
raise RuntimeError('No point provided')
if normal == None:
raise RuntimeError('No normal provided')
# Create plane
plane = vtk.vtkPlane()
plane.SetOrigin(pt[0], pt[1], pt[2])
plane.SetNormal(normal[0], normal[1], normal[2])
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputData(dataSet)
if delta == None:
cutter.Update()
return cutter.GetOutput()
else:
# Create a box
box = vtk.vtkBox()
box.SetBounds(pt[0]-delta, pt[0]+delta, pt[1]-delta, pt[1]+delta, pt[2]-delta, pt[2]+delta)
# Clip data with a box
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(box)
clipper.SetInputConnection(cutter.GetOutputPort())
clipper.InsideOutOn()
clipper.Update()
return clipper.GetOutput()
def clipDataSetWithPolygon(vtkDataSet,
vtkPoly,
returnImpDist=False,
insideOut=True,
extractBounds=False):
"""
Function to clips cells from a vtkDataSet, given polygon/s in a vtkPolyData.
Returns a clipped cells that fall inside or outside the polygon boundary.
"""
# Make a implicit function
impDist = convertToImplicitPolyDataDistance(vtkPoly)
# Reduce the data to the bounds
if extractBounds:
extBoundsFilt = extractDataSetByBounds(vtkDataSet, vtkPoly)
else:
extBoundsFilt = extractDataSetByBounds(vtkDataSet, vtkDataSet)
if vtkDataSet.IsA('vtkPolyData'):
clipFilt = vtk.vtkClipPolyData()
else:
clipFilt = vtk.vtkClipDataSet()
clipFilt.SetInsideOut(insideOut + 0)
clipFilt.SetInputConnection(extBoundsFilt.GetOutputPort())
clipFilt.SetClipFunction(impDist)
clipFilt.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
# clipFilt.SetMergeTolerance(0.000001)
clipFilt.Update()
if returnImpDist:
return clipFilt.GetOutput(), impDist
else:
return clipFilt.GetOutput()
def clip(inp, origin, normal, inside_out=False, take_cell=False):
"""
VTK operation: clip. A vtkGeometryFilter is used to convert the
resulted vtkUnstructuredMesh object into a vtkPolyData object.
@param inp: input VTK object.
@type inp: vtk.vtkobject
@param origin: a 3-tuple for cut origin.
@type origin: tuple
@param normal: a 3-tuple for cut normal.
@type normal: tuple
@keyword inside_out: make inside out. Default False.
@type inside_out: bool
@keyword take_cell: treat the input VTK object with values on cells.
Default False.
@type: take_cell: bool
@return: output VTK object.
@rtype: vtk.vtkobject
"""
import vtk
pne = vtk.vtkPlane()
pne.SetOrigin(origin)
pne.SetNormal(normal)
clip = vtk.vtkClipDataSet()
if take_cell:
clip.SetInput(inp)
else:
clip.SetInputConnection(inp.GetOutputPort())
clip.SetClipFunction(pne)
if inside_out:
clip.InsideOutOn()
parison = vtk.vtkGeometryFilter()
parison.SetInputConnection(clip.GetOutputPort())
return parison
def create_renderer_2(bone, skin):
'''
Return the second renderer
bone: the bone dataset
skin: the skin dataset
'''
# creating the sphere clipping
sphere = vtk.vtkSphere()
sphere.SetRadius(60)
sphere.SetCenter(70, 30, 100)
# clipping
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(sphere)
clipper.SetInputConnection(skin.GetOutputPort())
skin = clipper
# creating actors
bone_actor = create_actor(bone)
bone_actor.GetProperty().SetColor(0.94, 0.94, 0.94)
# spliting the skin in 2 different actors for front face opacity
frontface_actor = create_actor(skin)
frontface_actor.GetProperty().SetColor(0.8, 0.62, 0.62)
backface_actor = create_actor(skin)
backface_actor.GetProperty().SetColor(0.8, 0.62, 0.62)
backface_actor.GetProperty().FrontfaceCullingOn()
# changing opacity of the front one
frontface_actor.GetProperty().SetOpacity(0.6)
# creating renderer
ren = create_renderer([bone_actor, frontface_actor, backface_actor])
ren.SetBackground(0.824, 1, 0.824)
return ren
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkClipDataSet(), 'Processing.',
('vtkDataSet',), ('vtkUnstructuredGrid', 'vtkUnstructuredGrid'),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
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 ClipMesh(self):
meshClipFilter = vtk.vtkClipDataSet()
meshClipFilter.SetInputData(self.Mesh)
meshClipFilter.SetInsideOut(self.InsideOut)
clipPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(clipPlane)
meshClipFilter.SetClipFunction(clipPlane)
meshClipFilter.Update()
return meshClipFilter.GetOutput()
def ClipMesh(self):
meshClipFilter = vtk.vtkClipDataSet()
meshClipFilter.SetInputData(self.Mesh)
meshClipFilter.SetInsideOut(self.InsideOut)
clipPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(clipPlane)
meshClipFilter.SetClipFunction(clipPlane)
meshClipFilter.Update()
return meshClipFilter.GetOutput()
def clipData(inputData, distanceFunc, insideOut):
evalDistanceOnGrid("SignedDistance", inputData, distanceFunc)
clipper = vtk.vtkClipDataSet()
clipper.SetInputData(inputData)
if insideOut:
clipper.InsideOutOn()
clipper.SetValue(0.0)
clipper.Update()
return clipper.GetOutput()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self,
module_manager,
vtk.vtkClipDataSet(),
'Processing.', ('vtkDataSet', ),
('vtkUnstructuredGrid', 'vtkUnstructuredGrid'),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def clipVTK(meshVTK, th=0, scalarName='rvot', insideOut=False):
"""
Clips a mesh using VTK
"""
meshVTK.GetPointData().SetActiveScalars(scalarName)
clip = vtk.vtkClipDataSet()
clip.SetValue(th)
clip.SetInsideOut(insideOut)
clip.SetInputData(meshVTK)
clip.Update()
return clip.GetOutput()
def cutWithMesh(self,
mesh,
invert=False,
onlyTets=False,
onlyBoundary=False):
"""
Cut a ``TetMesh`` mesh with a ``Mesh``.
:param bool invert: if True return cut off part of the input TetMesh.
"""
polymesh = mesh.polydata()
ug = self._ugrid
scalname = ug.GetCellData().GetScalars().GetName()
ippd = vtk.vtkImplicitPolyDataDistance()
ippd.SetInput(polymesh)
if onlyTets or onlyBoundary:
clipper = vtk.vtkExtractGeometry()
clipper.SetInputData(ug)
clipper.SetImplicitFunction(ippd)
clipper.SetExtractInside(not invert)
clipper.SetExtractBoundaryCells(False)
if onlyBoundary:
clipper.SetExtractBoundaryCells(True)
clipper.SetExtractOnlyBoundaryCells(True)
else:
signedDistances = vtk.vtkFloatArray()
signedDistances.SetNumberOfComponents(1)
signedDistances.SetName("SignedDistances")
for pointId in range(ug.GetNumberOfPoints()):
p = ug.GetPoint(pointId)
signedDistance = ippd.EvaluateFunction(p)
signedDistances.InsertNextValue(signedDistance)
ug.GetPointData().SetScalars(signedDistances)
clipper = vtk.vtkClipDataSet()
clipper.SetInputData(ug)
clipper.SetInsideOut(not invert)
clipper.SetValue(0.0)
clipper.Update()
cug = clipper.GetOutput()
if scalname: # not working
if self.useCells:
self.selectCellArray(scalname)
else:
self.selectPointArray(scalname)
self._update(cug)
return self
def create_renderer_3(bone, skin):
'''
Return the third renderer
bone: the bone dataset
skin: the skin dataset
'''
# creating the sphere clipping
radius = 60
center = [70, 30, 100]
sphere = vtk.vtkSphere()
sphere.SetRadius(radius)
sphere.SetCenter(center)
# clipping
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(sphere)
clipper.SetInputConnection(skin.GetOutputPort())
skin = clipper
# creating actors
bone_actor = create_actor(bone)
bone_actor.GetProperty().SetColor(0.94, 0.94, 0.94)
skin_actor = create_actor(skin)
skin_actor.GetProperty().SetColor(0.8, 0.62, 0.62)
# creating the sphere actor ----
# sampling using the sphere implicit function
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(sphere)
sample.SetSampleDimensions(50, 50, 50)
sample.SetModelBounds(center[0] - radius, center[0] + radius,
center[1] - radius, center[1] + radius,
center[2] - radius, center[2] + radius)
# contouring. The sphere is described by a 0 iso-value
sphere_actor = create_iso_actor(sample, 0)
# design
sphere_actor.GetProperty().SetColor(0.85, 0.8, 0.1)
sphere_actor.GetProperty().SetOpacity(0.15)
# creating renderer
ren = create_renderer([bone_actor, skin_actor, sphere_actor])
ren.SetBackground(0.827, 0.824, 1)
return ren
def Clip_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)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(plane)
clipper.SetInputConnection(reader.GetOutputPort())
clipper.Update()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(clipper.GetOutput())
writer.SetFileName(outputFileName)
writer.Write()
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
self.Planes = vtk.vtkPlanes()
self.Clipper = vtk.vtkClipDataSet()
self.Clipper.SetInput(self.Mesh)
self.Clipper.SetClipFunction(self.Planes)
self.Clipper.GenerateClippedOutputOn()
self.Clipper.InsideOutOn()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(self.Mesh)
mapper.ScalarVisibilityOff()
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
self.BoxWidget = vtk.vtkBoxWidget()
self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.BoxWidget.GetFaceProperty().SetColor(0.6, 0.6, 0.2)
self.BoxWidget.GetFaceProperty().SetOpacity(0.25)
self.vmtkRenderer.AddKeyBinding('i', 'Interact.',
self.InteractCallback)
self.vmtkRenderer.AddKeyBinding('space', 'Clip.', self.ClipCallback)
self.Display()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
def new_implicit_plane_widget(
data_source) -> Tuple[vtk.vtkAbstractWidget, vtk.vtkProp]:
# This portion of the code clips the mace with the vtkPlanes
# implicit function. The clipped region is colored green.
select_plane = vtk.vtkPlane()
clipper = vtk.vtkClipDataSet()
clipper.SetInputConnection(data_source.GetOutputPort())
clipper.SetClipFunction(select_plane)
clipper.InsideOutOn()
selectMapper = vtk.vtkPolyDataMapper()
selectMapper.SetInputConnection(clipper.GetOutputPort())
selectActor = vtk.vtkActor()
selectActor.SetMapper(selectMapper)
selectActor.GetProperty().SetColor(0, 1, 1)
selectActor.VisibilityOff()
selectActor.SetScale(1.01, 1.01, 1.01)
# Associate the line widget with the interactor
planeRep = vtk.vtkImplicitPlaneRepresentation()
planeRep.SetPlaceFactor(2.0)
data_source.Update()
bounds = data_source.GetOutput().GetBounds()
origin = [
(bounds[0] + bounds[1]) / 2.0,
(bounds[2] + bounds[3]) / 2.0,
(bounds[4] + bounds[5]) / 2.0,
]
planeRep.PlaceWidget(bounds)
planeRep.SetOrigin(origin)
planeWidget = vtk.vtkImplicitPlaneWidget2()
planeWidget.SetRepresentation(planeRep)
# planeWidget.SetInputConnection(glyph.GetOutputPort())
def myCallback(obj, event):
planeRep.GetPlane(select_plane)
print("MYCALLBACK", type(obj), type(event), event)
selectActor.VisibilityOn()
planeWidget.AddObserver("InteractionEvent", myCallback)
return planeWidget, selectActor
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
self.Planes = vtk.vtkPlanes()
self.Clipper = vtk.vtkClipDataSet()
self.Clipper.SetInput(self.Mesh)
self.Clipper.SetClipFunction(self.Planes)
self.Clipper.GenerateClippedOutputOn()
self.Clipper.InsideOutOn()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(self.Mesh)
mapper.ScalarVisibilityOff()
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
self.BoxWidget = vtk.vtkBoxWidget()
self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.BoxWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
self.BoxWidget.GetFaceProperty().SetOpacity(0.25)
self.vmtkRenderer.AddKeyBinding('i','Interact.', self.InteractCallback)
self.vmtkRenderer.AddKeyBinding('space','Clip.', self.ClipCallback)
self.Display()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
def Clip_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)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(plane)
clipper.SetInputConnection(reader.GetOutputPort())
clipper.Update()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(clipper.GetOutput())
writer.SetFileName(outputFileName)
writer.Write()
def clip(dataset, normal='x', origin=None, invert=True):
"""
Clip a dataset by a plane by specifying the origin and normal. If no
parameters are given the clip will occur in the center of that dataset
dataset :
"""
if isinstance(normal, str):
normal = NORMALS[normal.lower()]
# find center of data if origin not specified
if origin is None:
origin = dataset.center
# create the plane for clipping
plane = _generate_plane(normal, origin)
# run the clip
alg = vtk.vtkClipDataSet()
alg.SetInputDataObject(
dataset) # Use the grid as the data we desire to cut
alg.SetClipFunction(plane) # the the cutter to use the plane we made
alg.SetInsideOut(invert) # invert the clip if needed
alg.Update() # Perfrom the Cut
return _get_output(alg)
def main():
# vtkFlyingEdges3D was introduced in VTK >= 8.2
use_flying_edges = vtk_version_ok(8, 2, 0)
colors = vtk.vtkNamedColors()
file_name = get_program_parameters()
colors.SetColor('SkinColor', [240, 184, 160, 255])
colors.SetColor('BackfaceColor', [255, 229, 200, 255])
colors.SetColor('BkgColor', [51, 77, 102, 255])
# Read the volume data
reader = vtk.vtkMetaImageReader()
reader.SetFileName(file_name)
reader.Update()
# An isosurface, or contour value of 500 is known to correspond to the
# skin of the patient.
if use_flying_edges:
try:
skin_extractor = vtk.vtkFlyingEdges3D()
except AttributeError:
skin_extractor = vtk.vtkMarchingCubes()
else:
skin_extractor = vtk.vtkMarchingCubes()
skin_extractor.SetInputConnection(reader.GetOutputPort())
skin_extractor.SetValue(0, 500)
# Define a spherical clip function to clip the isosurface
clip_function = vtk.vtkSphere()
clip_function.SetRadius(50)
clip_function.SetCenter(73, 52, 15)
# Clip the isosurface with a sphere
skin_clip = vtk.vtkClipDataSet()
skin_clip.SetInputConnection(skin_extractor.GetOutputPort())
skin_clip.SetClipFunction(clip_function)
skin_clip.SetValue(0)
skin_clip.GenerateClipScalarsOn()
skin_clip.Update()
skin_mapper = vtk.vtkDataSetMapper()
skin_mapper.SetInputConnection(skin_clip.GetOutputPort())
skin_mapper.ScalarVisibilityOff()
skin = vtk.vtkActor()
skin.SetMapper(skin_mapper)
skin.GetProperty().SetDiffuseColor(colors.GetColor3d('SkinColor'))
back_prop = vtk.vtkProperty()
back_prop.SetDiffuseColor(colors.GetColor3d('BackfaceColor'))
skin.SetBackfaceProperty(back_prop)
# Define a model for the "lens". Its geometry matches the implicit
# sphere used to clip the isosurface
lens_model = vtk.vtkSphereSource()
lens_model.SetRadius(50)
lens_model.SetCenter(73, 52, 15)
lens_model.SetPhiResolution(201)
lens_model.SetThetaResolution(101)
# Sample the input volume with the lens model geometry
lens_probe = vtk.vtkProbeFilter()
lens_probe.SetInputConnection(lens_model.GetOutputPort())
lens_probe.SetSourceConnection(reader.GetOutputPort())
# Clip the lens data with the isosurface value
lens_clip = vtk.vtkClipDataSet()
lens_clip.SetInputConnection(lens_probe.GetOutputPort())
lens_clip.SetValue(500)
lens_clip.GenerateClipScalarsOff()
lens_clip.Update()
# Define a suitable grayscale lut
bw_lut = vtk.vtkLookupTable()
bw_lut.SetTableRange(0, 2048)
bw_lut.SetSaturationRange(0, 0)
bw_lut.SetHueRange(0, 0)
bw_lut.SetValueRange(0.2, 1)
bw_lut.Build()
lens_mapper = vtk.vtkDataSetMapper()
lens_mapper.SetInputConnection(lens_clip.GetOutputPort())
lens_mapper.SetScalarRange(lens_clip.GetOutput().GetScalarRange())
lens_mapper.SetLookupTable(bw_lut)
lens = vtk.vtkActor()
lens.SetMapper(lens_mapper)
# It is convenient to create an initial view of the data. The FocalPoint
# and Position form a vector direction. Later on (ResetCamera() method)
# this vector is used to position the camera to look at the data in
# this direction.
a_camera = vtk.vtkCamera()
a_camera.SetViewUp(0, 0, -1)
a_camera.SetPosition(0, -1, 0)
a_camera.SetFocalPoint(0, 0, 0)
a_camera.ComputeViewPlaneNormal()
a_camera.Azimuth(30.0)
a_camera.Elevation(30.0)
# Create the renderer, the render window, and the interactor. The renderer
# draws into the render window, the interactor enables mouse- and
# keyboard-based interaction with the data within the render window.
#
a_renderer = vtk.vtkRenderer()
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(a_renderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
# Actors are added to the renderer. An initial camera view is created.
# The Dolly() method moves the camera towards the FocalPoint,
# thereby enlarging the image.
a_renderer.AddActor(lens)
a_renderer.AddActor(skin)
a_renderer.SetActiveCamera(a_camera)
a_renderer.ResetCamera()
a_camera.Dolly(1.5)
# Set a background color for the renderer and set the size of the
# render window (expressed in pixels).
a_renderer.SetBackground(colors.GetColor3d('BkgColor'))
ren_win.SetSize(640, 480)
ren_win.SetWindowName('TissueLens')
# Note that when camera movement occurs (as it does in the Dolly()
# method), the clipping planes often need adjusting. Clipping planes
# consist of two planes: near and far along the view direction. The
# near plane clips out objects in front of the plane the far plane
# clips out objects behind the plane. This way only what is drawn
# between the planes is actually rendered.
a_renderer.ResetCameraClippingRange()
# Initialize the event loop and then start it.
ren_win.Render()
iren.Initialize()
iren.Start()
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
if (self.Centerlines == None):
self.PrintError('Error: no Centerlines')
#Save the centerlines
previousCenterlines = self.Centerlines
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInput(self.Centerlines)
cleaner.Update()
self.Centerlines = cleaner.GetOutput()
if self.Tolerance == -1:
self.Tolerance = 0.000001*self.Mesh.GetLength()
if self.RadiusArrayName != '':
self.RadiusArray = self.Centerlines.GetPointData().GetArray(self.RadiusArrayName)
if self.RadiusArray == None:
self.PrintError('Error : could not find radius array')
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
meshMapper = vtk.vtkDataSetMapper()
meshMapper.SetInput(self.Mesh)
meshMapper.ScalarVisibilityOff()
self.MeshActor = vtk.vtkActor()
self.MeshActor.SetMapper(meshMapper)
self.MeshActor.GetProperty().SetOpacity(0.25)
self.MeshActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.MeshActor)
centerlinesMapper = vtk.vtkDataSetMapper()
centerlinesMapper.SetInput(self.Centerlines)
centerlinesMapper.ScalarVisibilityOff()
self.CenterlinesActor = vtk.vtkActor()
self.CenterlinesActor.SetMapper(centerlinesMapper)
self.vmtkRenderer.Renderer.AddActor(self.CenterlinesActor)
glyphs = vtk.vtkGlyph3D()
glyphSource = vtk.vtkSphereSource()
glyphSource.SetRadius(1)
glyphs.SetInput(self.Spheres)
glyphs.SetSource(glyphSource.GetOutput())
glyphs.SetScaleModeToScaleByScalar()
glyphs.SetScaleFactor(1.)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInput(glyphs.GetOutput())
glyphMapper.ScalarVisibilityOff()
self.SpheresActor = vtk.vtkActor()
self.SpheresActor.SetMapper(glyphMapper)
self.SpheresActor.GetProperty().SetColor(1.0,0.0,0.0)
self.SpheresActor.GetProperty().SetOpacity(0.25)
self.SpheresActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.SpheresActor)
self.InterpolatedGlyphs = vtk.vtkGlyph3D()
interpolatedGlyphSource = vtk.vtkSphereSource()
interpolatedGlyphSource.SetRadius(1)
self.InterpolatedGlyphs.SetInput(self.Centerlines)
self.InterpolatedGlyphs.SetSource(interpolatedGlyphSource.GetOutput())
#scaling is off for now
self.InterpolatedGlyphs.SetScaleModeToDataScalingOff()
self.InterpolatedGlyphs.SetScaleFactor(0.)
interpolatedGlyphMapper = vtk.vtkPolyDataMapper()
interpolatedGlyphMapper.SetInput(self.InterpolatedGlyphs.GetOutput())
interpolatedGlyphMapper.ScalarVisibilityOff()
self.InterpolatedSpheresActor = vtk.vtkActor()
self.InterpolatedSpheresActor.SetMapper(interpolatedGlyphMapper)
self.InterpolatedSpheresActor.GetProperty().SetColor(0.0,1.0,0.0)
self.InterpolatedSpheresActor.GetProperty().SetOpacity(0.25)
self.InterpolatedSpheresActor.PickableOff()
self.InterpolatedSpheresActor.VisibilityOff()
self.vmtkRenderer.Renderer.AddActor(self.InterpolatedSpheresActor)
polyBallMapper = vtk.vtkPolyDataMapper()
polyBallMapper.ScalarVisibilityOff()
self.PolyBallActor = vtk.vtkActor()
self.PolyBallActor.SetMapper(polyBallMapper)
self.PolyBallActor.GetProperty().SetColor(0.0,1.0,0.0)
self.PolyBallActor.GetProperty().SetOpacity(0.25)
self.PolyBallActor.PickableOff()
self.PolyBallActor.VisibilityOff()
self.vmtkRenderer.Renderer.AddActor(self.PolyBallActor)
self.SphereWidget = vtk.vtkSphereWidget()
self.SphereWidget.TranslationOff()
self.SphereWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.SphereWidget.AddObserver("InteractionEvent", self.SphereCallback)
self.Clipper = vtk.vtkClipDataSet()
self.Clipper.SetInput(self.Mesh)
self.Clipper.SetInsideOut(self.InsideOut)
self.Clipper.GenerateClippedOutputOn()
#self.LineClipper = vtkvmtk.vtkvmtkClipDataSetLine()
#self.LineClipper.SetInput(self.Mesh)
#self.LineClipper.SetInsideOut(self.InsideOut)
#self.LineClipper.GenerateClippedOutputOn()
self.InitializeSpheres()
self.PreviewMesh = self.Mesh
self.Display()
self.PolyBallActor.VisibilityOff()
self.ClipMesh()
if self.ClippedMesh == None:
#return an empty mesh
self.ClippedMesh = vtk.vtkUnstructuredGrid()
elif self.IncludeSurfaceCells:
#Create the surface cells
self.PreviewMesh = self.CreateSurfaceCells(self.PreviewMesh)
self.ClippedMesh = self.CreateSurfaceCells(self.ClippedMesh)
self.Mesh = self.PreviewMesh
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
#Restore the centerlines
self.Centerlines = previousCenterlines
reader.SetFileName(objectPath) reader.Update() # plane = vtk.vtkPlane() # plane.SetOrigin(reader.GetOutput().GetCenter()) # plane.SetNormal(0.5, 0.5, 0.5) # planeClip = vtk.vtkClipDataSet() # planeClip.SetInputConnection(reader.GetOutputPort()) # planeClip.SetClipFunction(plane) sphere = vtk.vtkSphere() sphere.SetCenter(0, 0, 0) sphere.SetRadius(30) sphereClip = vtk.vtkClipDataSet() sphereClip.SetInputConnection(reader.GetOutputPort()) sphereClip.SetClipFunction(sphere) clipMapper = vtk.vtkDataSetMapper() # clipMapper.SetInputConnection(planeClip.GetOutputPort()) clipMapper.SetInputConnection(sphereClip.GetOutputPort()) clipMapper.SetScalarRange(reader.GetOutput().GetScalarRange()) actor = vtk.vtkActor() actor.SetMapper(clipMapper) # Create a rendering window and renderer renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow()
actoriso = vtk.vtkActor() actoriso.SetMapper(mapperiso) # Disable the scalar coloring mapperiso.ScalarVisibilityOff() # Set the color to black actoriso.GetProperty().SetColor(0, 0, 0) # Set the line width larger actoriso.GetProperty().SetLineWidth(2) # add the actor to the rendering renderer.AddViewProp(actoriso) # Step 7 - Clipping the data # Remove first the iso actor renderer.RemoveViewProp(actoriso) # Clip the data cf = vtk.vtkClipDataSet() # Set the clipping plane plane = vtk.vtkPlane() cf.SetClipFunction(plane) print plane # Set the plane origin plane.SetOrigin(560000, 5120000, 2000) # Connect the pipeline cf.SetInputConnection(warp.GetOutputPort()) mapper.SetInputConnection(cf.GetOutputPort()) # Step 8 - Clipping Widget interaction # Creates an implicit plane widget widget = vtk.vtkImplicitPlaneWidget() widget.PlaceWidget(warp.GetOutput().GetBounds()) widget.SetOrigin([plane.GetOrigin()[x] for x in 0, 1, 2])
aWedge.GetPointIds().SetId(5, 5) aWedge.GetPointIds().SetId(6, 6) aWedge.GetPointIds().SetId(7, 7) aWedge.GetPointIds().SetId(8, 8) aWedge.GetPointIds().SetId(9, 9) aWedge.GetPointIds().SetId(10, 10) aWedge.GetPointIds().SetId(11, 11) aWedge.GetPointIds().SetId(12, 12) aWedge.GetPointIds().SetId(13, 13) aWedge.GetPointIds().SetId(14, 14) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeGrid.GetPointData().SetScalars(wedgeScalars) wedgeContours = vtk.vtkClipDataSet() wedgeContours.SetInputData(aWedgeGrid) wedgeContours.SetValue(0.5) aWedgeContourMapper = vtk.vtkDataSetMapper() aWedgeContourMapper.SetInputConnection(wedgeContours.GetOutputPort()) aWedgeContourMapper.ScalarVisibilityOff() aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeGrid) aWedgeMapper.ScalarVisibilityOff() aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.GetProperty().SetRepresentationToWireframe() aWedgeActor.GetProperty().SetAmbient(1.0) aWedgeContourActor = vtk.vtkActor() aWedgeContourActor.SetMapper(aWedgeContourMapper) aWedgeContourActor.GetProperty().SetAmbient(1.0)
def __init__(self, slider_x, slider_y, slider_z, parent=None):
super(VTK_Widget1, self).__init__(parent)
self.source_is_connected = False
self.slider_x = slider_x
self.slider_y = slider_y
self.slider_z = slider_z
# vtk to point data
self.c2p = vtk.vtkCellDataToPointData()
self.opacityTransferFunction = vtk.vtkPiecewiseFunction()
self.colorTransferFunction = vtk.vtkColorTransferFunction()
# clip plane
self.clip_plane = vtk.vtkPlane()
self.clip_plane.SetNormal(0, 0, 1)
self.clipper = vtk.vtkClipDataSet()
self.clipper.SetClipFunction(self.clip_plane)
self.clipper.SetInputConnection(self.c2p.GetOutputPort())
# 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.clipper.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(33)
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()
# Associate the line widget with the interactor
self.planeWidget = vtk.vtkImplicitPlaneWidget()
self.planeWidget.SetInteractor(self.vtkw)
self.planeWidget.AddObserver("InteractionEvent", self.PlaneWidgetCallback)
self.planeWidget.DrawPlaneOff()
self.planeWidget.TubingOn()
[0.5, 0.25, 0]])
edgePoints.SetData(ntov(edgePointsCoords))
edgeScalars = vtk.vtkFloatArray()
edgeScalars.SetNumberOfTuples(3)
edgeScalars.InsertValue(0, 0.0)
edgeScalars.InsertValue(1, 0.0)
edgeScalars.InsertValue(2, 0.9)
aEdge = vtk.vtkQuadraticEdge()
for i in range(aEdge.GetNumberOfPoints()):
aEdge.GetPointIds().SetId(i, i)
aEdgeGrid = vtk.vtkUnstructuredGrid()
aEdgeGrid.Allocate(1, 1)
aEdgeGrid.InsertNextCell(aEdge.GetCellType(), aEdge.GetPointIds())
aEdgeGrid.SetPoints(edgePoints)
aEdgeGrid.GetPointData().SetScalars(edgeScalars)
edgeclips = vtk.vtkClipDataSet()
edgeclips.SetInputData(aEdgeGrid)
edgeclips.SetValue(0.5)
aEdgeclipMapper = vtk.vtkDataSetMapper()
aEdgeclipMapper.SetInputConnection(edgeclips.GetOutputPort())
aEdgeclipMapper.ScalarVisibilityOff()
aEdgeMapper = vtk.vtkDataSetMapper()
aEdgeMapper.SetInputData(aEdgeGrid)
aEdgeMapper.ScalarVisibilityOff()
aEdgeActor = vtk.vtkActor()
aEdgeActor.SetMapper(aEdgeMapper)
aEdgeActor.GetProperty().SetRepresentationToWireframe()
aEdgeActor.GetProperty().SetAmbient(1.0)
aEdgeclipActor = vtk.vtkActor()
aEdgeclipActor.SetMapper(aEdgeclipMapper)
aEdgeclipActor.GetProperty().BackfaceCullingOn()
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
if (self.Centerlines == None):
self.PrintError('Error: no Centerlines')
#Save the centerlines
previousCenterlines = self.Centerlines
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputData(self.Centerlines)
cleaner.Update()
self.Centerlines = cleaner.GetOutput()
if self.Tolerance == -1:
self.Tolerance = 0.000001*self.Mesh.GetLength()
if self.RadiusArrayName != '':
self.RadiusArray = self.Centerlines.GetPointData().GetArray(self.RadiusArrayName)
if self.RadiusArray == None:
self.PrintError('Error : could not find radius array')
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
meshMapper = vtk.vtkDataSetMapper()
meshMapper.SetInputData(self.Mesh)
meshMapper.ScalarVisibilityOff()
self.MeshActor = vtk.vtkActor()
self.MeshActor.SetMapper(meshMapper)
self.MeshActor.GetProperty().SetOpacity(0.25)
self.MeshActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.MeshActor)
centerlinesMapper = vtk.vtkDataSetMapper()
centerlinesMapper.SetInputData(self.Centerlines)
centerlinesMapper.ScalarVisibilityOff()
self.CenterlinesActor = vtk.vtkActor()
self.CenterlinesActor.SetMapper(centerlinesMapper)
self.vmtkRenderer.Renderer.AddActor(self.CenterlinesActor)
glyphs = vtk.vtkGlyph3D()
glyphSource = vtk.vtkSphereSource()
glyphSource.SetRadius(1)
glyphs.SetInputData(self.Spheres)
glyphs.SetSourceConnection(glyphSource.GetOutputPort())
glyphs.SetScaleModeToScaleByScalar()
glyphs.SetScaleFactor(1.)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyphs.GetOutput())
glyphMapper.ScalarVisibilityOff()
self.SpheresActor = vtk.vtkActor()
self.SpheresActor.SetMapper(glyphMapper)
self.SpheresActor.GetProperty().SetColor(1.0,0.0,0.0)
self.SpheresActor.GetProperty().SetOpacity(0.25)
self.SpheresActor.PickableOff()
self.vmtkRenderer.Renderer.AddActor(self.SpheresActor)
self.InterpolatedGlyphs = vtk.vtkGlyph3D()
interpolatedGlyphSource = vtk.vtkSphereSource()
interpolatedGlyphSource.SetRadius(1)
self.InterpolatedGlyphs.SetInputData(self.Centerlines)
self.InterpolatedGlyphs.SetSourceConnection(interpolatedGlyphSource.GetOutputPort())
#scaling is off for now
self.InterpolatedGlyphs.SetScaleModeToDataScalingOff()
self.InterpolatedGlyphs.SetScaleFactor(0.)
interpolatedGlyphMapper = vtk.vtkPolyDataMapper()
interpolatedGlyphMapper.SetInputConnection(self.InterpolatedGlyphs.GetOutputPort())
interpolatedGlyphMapper.ScalarVisibilityOff()
self.InterpolatedSpheresActor = vtk.vtkActor()
self.InterpolatedSpheresActor.SetMapper(interpolatedGlyphMapper)
self.InterpolatedSpheresActor.GetProperty().SetColor(0.0,1.0,0.0)
self.InterpolatedSpheresActor.GetProperty().SetOpacity(0.25)
self.InterpolatedSpheresActor.PickableOff()
self.InterpolatedSpheresActor.VisibilityOff()
self.vmtkRenderer.Renderer.AddActor(self.InterpolatedSpheresActor)
polyBallMapper = vtk.vtkPolyDataMapper()
polyBallMapper.ScalarVisibilityOff()
self.PolyBallActor = vtk.vtkActor()
self.PolyBallActor.SetMapper(polyBallMapper)
self.PolyBallActor.GetProperty().SetColor(0.0,1.0,0.0)
self.PolyBallActor.GetProperty().SetOpacity(0.25)
self.PolyBallActor.PickableOff()
self.PolyBallActor.VisibilityOff()
self.vmtkRenderer.Renderer.AddActor(self.PolyBallActor)
self.SphereWidget = vtk.vtkSphereWidget()
self.SphereWidget.TranslationOff()
self.SphereWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.SphereWidget.AddObserver("InteractionEvent", self.SphereCallback)
self.Clipper = vtk.vtkClipDataSet()
self.Clipper.SetInputData(self.Mesh)
self.Clipper.SetInsideOut(self.InsideOut)
self.Clipper.GenerateClippedOutputOn()
#self.LineClipper = vtkvmtk.vtkvmtkClipDataSetLine()
#self.LineClipper.SetInputData(self.Mesh)
#self.LineClipper.SetInsideOut(self.InsideOut)
#self.LineClipper.GenerateClippedOutputOn()
self.InitializeSpheres()
self.PreviewMesh = self.Mesh
self.Display()
self.PolyBallActor.VisibilityOff()
self.ClipMesh()
if self.ClippedMesh == None:
#return an empty mesh
self.ClippedMesh = vtk.vtkUnstructuredGrid()
elif self.IncludeSurfaceCells:
#Create the surface cells
self.PreviewMesh = self.CreateSurfaceCells(self.PreviewMesh)
self.ClippedMesh = self.CreateSurfaceCells(self.ClippedMesh)
self.Mesh = self.PreviewMesh
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
#Restore the centerlines
self.Centerlines = previousCenterlines
def AddPolyData(self, polydata, property, thickness):
doit = True
if (not polydata or self.HasDataSet(polydata) or not self.Image):
doit = False
if doit:
if thickness:
self.BoxThickness = thickness
clipper = vtk.vtkClipDataSet()
clipper.GenerateClippedOutputOff()
clipper.InsideOutOn()
clipper.SetInput(polydata)
direction = self.GetOrthogonalAxis(self.Orientation)
if direction == vtkViewImage.X_ID:
self.DataSetCutBox.SetBounds( self.DataSetCutPlane.GetOrigin()[0]-0.5*self.BoxThickness,
self.DataSetCutPlane.GetOrigin()[1]+0.5*self.BoxThickness,
self.GetWholeMinPosition(1),
self.GetWholeMaxPosition(1),
self.GetWholeMinPosition(2),
self.GetWholeMaxPosition(2))
elif direction == vtkViewImage.Y_ID:
self.DataSetCutBox.SetBounds( self.GetWholeMinPosition(0),
self.GetWholeMaxPosition(0),
self.DataSetCutPlane.GetOrigin()[0]-0.5*self.BoxThickness,
self.DataSetCutPlane.GetOrigin()[1]+0.5*self.BoxThickness,
self.GetWholeMinPosition(2),
self.GetWholeMaxPosition(2))
elif direction == vtkViewImage.Z_ID:
self.DataSetCutBox.SetBounds( self.GetWholeMinPosition(0),
self.GetWholeMaxPosition(0),
self.GetWholeMinPosition(1),
self.GetWholeMaxPosition(1),
self.DataSetCutPlane.GetOrigin()[0]-0.5*self.BoxThickness,
self.DataSetCutPlane.GetOrigin()[1]+0.5*self.BoxThickness
)
clipper.SetClipFunction(self.DataSetCutBox)
clipper.Update()
matrix = vtk.vtkMatrix4x4()
for i in range(3):
for j in range(3):
matrix.SetElement(i,j,self.ImageReslice.GetResliceAxes().GetElement(j,i))
matrix.SetElement(3, 3, 1)
mapper= vtk.vtkDataSetMapper()
mapper.SetInput(clipper.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetUseMatrix(matrix)
if property:
actor.SetProperty(property)
self.AddActor(actor)
self.DataSetList.append(polydata)
self.DataSetActorList.append(actor)
self.ResetAndRestablishZoomAndCamera()
del actor
del mapper
del matrix
del clipper
return self.GetDataSetActor(polydata)
aWedge.GetPointIds().SetId(5, 5) aWedge.GetPointIds().SetId(6, 6) aWedge.GetPointIds().SetId(7, 7) aWedge.GetPointIds().SetId(8, 8) aWedge.GetPointIds().SetId(9, 9) aWedge.GetPointIds().SetId(10, 10) aWedge.GetPointIds().SetId(11, 11) aWedge.GetPointIds().SetId(12, 12) aWedge.GetPointIds().SetId(13, 13) aWedge.GetPointIds().SetId(14, 14) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeGrid.GetPointData().SetScalars(wedgeScalars) wedgeContours = vtk.vtkClipDataSet() wedgeContours.SetInputData(aWedgeGrid) wedgeContours.SetValue(0.5) aWedgeContourMapper = vtk.vtkDataSetMapper() aWedgeContourMapper.SetInputConnection(wedgeContours.GetOutputPort()) aWedgeContourMapper.ScalarVisibilityOff() aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeGrid) aWedgeMapper.ScalarVisibilityOff() aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.GetProperty().SetRepresentationToWireframe() aWedgeActor.GetProperty().SetAmbient(1.0) aWedgeContourActor = vtk.vtkActor() aWedgeContourActor.SetMapper(aWedgeContourMapper) aWedgeContourActor.GetProperty().SetAmbient(1.0)
def main():
filename = get_program_parameters()
# Create the reader for the data.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
bounds = reader.GetOutput().GetBounds()
center = reader.GetOutput().GetCenter()
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d("Wheat"))
renderer.UseHiddenLineRemovalOn()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
xnorm = [-1.0, -1.0, 1.0]
clipPlane = vtk.vtkPlane()
clipPlane.SetOrigin(reader.GetOutput().GetCenter())
clipPlane.SetNormal(xnorm)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(clipPlane)
clipper.SetInputData(reader.GetOutput())
clipper.SetValue(0.0)
clipper.GenerateClippedOutputOn()
clipper.Update()
insideMapper = vtk.vtkDataSetMapper()
insideMapper.SetInputData(clipper.GetOutput())
insideMapper.ScalarVisibilityOff()
insideActor = vtk.vtkActor()
insideActor.SetMapper(insideMapper)
insideActor.GetProperty().SetDiffuseColor(colors.GetColor3d("banana"))
insideActor.GetProperty().SetAmbient(.3)
insideActor.GetProperty().EdgeVisibilityOn()
clippedMapper = vtk.vtkDataSetMapper()
clippedMapper.SetInputData(clipper.GetClippedOutput())
clippedMapper.ScalarVisibilityOff()
clippedActor = vtk.vtkActor()
clippedActor.SetMapper(clippedMapper)
clippedActor.GetProperty().SetDiffuseColor(colors.GetColor3d("tomato"))
insideActor.GetProperty().SetAmbient(.3)
clippedActor.GetProperty().EdgeVisibilityOn()
# Create transforms to make a better visualization
insideTransform = vtk.vtkTransform()
insideTransform.Translate(-(bounds[1] - bounds[0]) * 0.75, 0, 0)
insideTransform.Translate(center[0], center[1], center[2])
insideTransform.RotateY(-120.0)
insideTransform.Translate(-center[0], -center[1], -center[2])
insideActor.SetUserTransform(insideTransform)
clippedTransform = vtk.vtkTransform()
clippedTransform.Translate((bounds[1] - bounds[0]) * 0.75, 0, 0)
clippedTransform.Translate(center[0], center[1], center[2])
clippedTransform.RotateY(60.0)
clippedTransform.Translate(-center[0], -center[1], -center[2])
clippedActor.SetUserTransform(clippedTransform)
renderer.AddViewProp(clippedActor)
renderer.AddViewProp(insideActor)
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(1.4)
renderer.ResetCameraClippingRange()
renderWindow.Render()
renderWindow.SetWindowName('ClipUnstructuredGridWithPlane2')
renderWindow.Render()
interactor.Start()
# Generate a report
numberOfCells = clipper.GetOutput().GetNumberOfCells()
print("------------------------")
print("The inside dataset contains a \n",
clipper.GetOutput().GetClassName(), " that has ", numberOfCells,
" cells")
cellMap = dict()
for i in range(0, numberOfCells):
cellMap.setdefault(clipper.GetOutput().GetCellType(i), 0)
cellMap[clipper.GetOutput().GetCellType(i)] += 1
# Sort by key and put into an OrderedDict.
# An OrderedDict remembers the order in which the keys have been inserted.
for k, v in collections.OrderedDict(sorted(cellMap.items())).items():
print("\tCell type ", vtk.vtkCellTypes.GetClassNameFromTypeId(k),
" occurs ", v, " times.")
numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
print("------------------------")
print("The clipped dataset contains a \n",
clipper.GetClippedOutput().GetClassName(), " that has ",
numberOfCells, " cells")
outsideCellMap = dict()
for i in range(0, numberOfCells):
outsideCellMap.setdefault(clipper.GetClippedOutput().GetCellType(i), 0)
outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] += 1
for k, v in collections.OrderedDict(sorted(
outsideCellMap.items())).items():
print("\tCell type ", vtk.vtkCellTypes.GetClassNameFromTypeId(k),
" occurs ", v, " times.")
def main():
colors = vtk.vtkNamedColors()
# Create polydata to slice the grid with. In this case, use a cone. This
# could
# be any polydata including a stl file.
cone = vtk.vtkConeSource()
cone.SetResolution(50)
cone.SetDirection(0, 0, -1)
cone.SetHeight(3.0)
cone.CappingOn()
cone.Update()
# Implicit function that will be used to slice the mesh
implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
implicitPolyDataDistance.SetInput(cone.GetOutput())
# create a grid
dimension = 51
xCoords = vtk.vtkFloatArray()
for x, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
xCoords.InsertNextValue(i)
yCoords = vtk.vtkFloatArray()
for y, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
yCoords.InsertNextValue(i)
zCoords = vtk.vtkFloatArray()
for z, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
zCoords.InsertNextValue(i)
# # create a grid - if not using numpy
# dimension = 51
# xCoords = vtk.vtkFloatArray()
# for i in range(0, dimension):
# xCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
#
# yCoords = vtk.vtkFloatArray()
# for i in range(0, dimension):
# yCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
#
# zCoords = vtk.vtkFloatArray()
# for i in range(0, dimension):
# zCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
# The coordinates are assigned to the rectilinear grid. Make sure that
# the number of values in each of the XCoordinates, YCoordinates,
# and ZCoordinates is equal to what is defined in SetDimensions().
rgrid = vtk.vtkRectilinearGrid()
rgrid.SetDimensions(xCoords.GetNumberOfTuples(),
yCoords.GetNumberOfTuples(),
zCoords.GetNumberOfTuples())
rgrid.SetXCoordinates(xCoords)
rgrid.SetYCoordinates(yCoords)
rgrid.SetZCoordinates(zCoords)
# Create an array to hold distance information
signedDistances = vtk.vtkFloatArray()
signedDistances.SetNumberOfComponents(1)
signedDistances.SetName('SignedDistances')
# Evaluate the signed distance function at all of the grid points
for pointId in range(0, rgrid.GetNumberOfPoints()):
p = rgrid.GetPoint(pointId)
signedDistance = implicitPolyDataDistance.EvaluateFunction(p)
signedDistances.InsertNextValue(signedDistance)
# Add the SignedDistances to the grid
rgrid.GetPointData().SetScalars(signedDistances)
# Use vtkClipDataSet to slice the grid with the polydata
clipper = vtk.vtkClipDataSet()
clipper.SetInputData(rgrid)
clipper.InsideOutOn()
clipper.SetValue(0.0)
clipper.GenerateClippedOutputOn()
clipper.Update()
# --- mappers, actors, render, etc. ---
# mapper and actor to view the cone
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
# geometry filter to view the background grid
geometryFilter = vtk.vtkRectilinearGridGeometryFilter()
geometryFilter.SetInputData(rgrid)
geometryFilter.SetExtent(0, dimension, 0, dimension, int(dimension / 2), int(dimension / 2))
geometryFilter.Update()
rgridMapper = vtk.vtkPolyDataMapper()
rgridMapper.SetInputConnection(geometryFilter.GetOutputPort())
rgridMapper.SetScalarRange(
rgrid.GetPointData().GetArray('SignedDistances').GetRange())
wireActor = vtk.vtkActor()
wireActor.SetMapper(rgridMapper)
wireActor.GetProperty().SetRepresentationToWireframe()
# mapper and actor to view the clipped mesh
clipperMapper = vtk.vtkDataSetMapper()
clipperMapper.SetInputConnection(clipper.GetOutputPort())
clipperMapper.ScalarVisibilityOff()
clipperOutsideMapper = vtk.vtkDataSetMapper()
clipperOutsideMapper.SetInputConnection(clipper.GetOutputPort(1))
clipperOutsideMapper.ScalarVisibilityOff()
clipperActor = vtk.vtkActor()
clipperActor.SetMapper(clipperMapper)
clipperActor.GetProperty().SetColor(colors.GetColor3d('Banana'))
clipperOutsideActor = vtk.vtkActor()
clipperOutsideActor.SetMapper(clipperOutsideMapper)
clipperOutsideActor.GetProperty().SetColor(
colors.GetColor3d('Banana'))
# A renderer and render window
# Create a renderer, render window, and interactor
leftViewport = [0.0, 0.0, 0.5, 1.0]
leftRenderer = vtk.vtkRenderer()
leftRenderer.SetViewport(leftViewport)
leftRenderer.SetBackground(colors.GetColor3d('SteelBlue'))
rightViewport = [0.5, 0.0, 1.0, 1.0]
rightRenderer = vtk.vtkRenderer()
rightRenderer.SetViewport(rightViewport)
rightRenderer.SetBackground(colors.GetColor3d('CadetBlue'))
# add the actors
leftRenderer.AddActor(wireActor)
leftRenderer.AddActor(clipperActor)
rightRenderer.AddActor(clipperOutsideActor)
renwin = vtk.vtkRenderWindow()
renwin.SetSize(640, 480)
renwin.AddRenderer(leftRenderer)
renwin.AddRenderer(rightRenderer)
renwin.SetWindowName('ClipDataSetWithPolyData')
# An interactor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
# Share the camera
leftRenderer.GetActiveCamera().SetPosition(0, -1, 0)
leftRenderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
leftRenderer.GetActiveCamera().SetViewUp(0, 0, 1)
leftRenderer.GetActiveCamera().Azimuth(30)
leftRenderer.GetActiveCamera().Elevation(30)
leftRenderer.ResetCamera()
rightRenderer.SetActiveCamera(leftRenderer.GetActiveCamera())
renwin.Render()
interactor.Start()
# Generate a report
ct = vtk.vtkCellTypes()
numberOfCells = clipper.GetOutput().GetNumberOfCells()
print('------------------------')
print('The clipped dataset(inside) contains a\n', clipper.GetOutput().GetClassName(), 'that has', numberOfCells,
'cells')
cellMap = dict()
for i in range(0, numberOfCells):
cellMap[clipper.GetOutput().GetCellType(i)] = cellMap.get(clipper.GetOutput().GetCellType(i), 0) + 1
for k, v in cellMap.items():
print('\tCell type ', ct.GetClassNameFromTypeId(k), 'occurs', v, 'times.')
numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
print('------------------------')
print('The clipped dataset(outside) contains a\n', clipper.GetClippedOutput().GetClassName(), 'that has',
numberOfCells, 'cells')
outsideCellMap = dict()
for i in range(0, numberOfCells):
outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] = outsideCellMap.get(
clipper.GetClippedOutput().GetCellType(i), 0) + 1
for k, v in outsideCellMap.items():
print('\tCell type ', ct.GetClassNameFromTypeId(k), 'occurs', v, 'times.')
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.Mesh == None:
self.PrintError("Error: no Mesh.")
self.Clipper = vtk.vtkClipDataSet()
self.Clipper.SetInput(self.Mesh)
self.Clipper.GenerateClippedOutputOn()
self.Clipper.SetInsideOut(self.InsideOut)
if self.Interactive:
self.Planes = vtk.vtkPlanes()
self.Clipper.SetClipFunction(self.Planes)
self.Cutter = vtk.vtkCutter()
self.Cutter.SetInput(self.Mesh)
self.Cutter.SetCutFunction(self.Planes)
self.ClippedMesh = vtk.vtkUnstructuredGrid()
self.Surface = vtk.vtkPolyData()
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(self.Mesh)
mapper.ScalarVisibilityOff()
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
self.BoxWidget = vtk.vtkBoxWidget()
self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.BoxWidget.GetFaceProperty().SetColor(0.6, 0.6, 0.2)
self.BoxWidget.GetFaceProperty().SetOpacity(0.25)
self.vmtkRenderer.AddKeyBinding("i", "Interact.", self.InteractCallback)
self.vmtkRenderer.AddKeyBinding("space", "Clip.", self.ClipCallback)
self.Display()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
else:
self.Mesh.GetPointData().SetActiveScalars(self.ClipArrayName)
self.Clipper.GenerateClipScalarsOff()
self.Clipper.SetValue(self.ClipValue)
self.Clipper.Update()
self.Cutter = vtk.vtkContourFilter()
self.Cutter.SetInput(self.Mesh)
self.Cutter.SetValue(0, self.ClipValue)
self.Cutter.Update()
self.Mesh = self.Clipper.GetOutput()
self.Surface = self.Cutter.GetOutput()
self.ClippedMesh = self.Clipper.GetClippedOutput()
if self.Mesh.GetSource():
self.Mesh.GetSource().UnRegisterAllOutputs()
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())
actoriso.GetProperty().SetColor(0,0,0) # Set the line width larger actoriso.GetProperty().SetLineWidth(2) # add the actor to the rendering renderer.AddViewProp(actoriso) # Start the UI Loop iren.Initialize() renwin.Render() iren.Start() # Removes the iso actor renderer.RemoveViewProp(actoriso) # Clip the data cf = vtk.vtkClipDataSet() # Set the clipping plane plane = vtk.vtkPlane() cf.SetClipFunction(plane) print plane # Set the plane origin plane.SetOrigin(560000,5120000,2000) # Connect the pipeline cf.SetInputConnection(warp.GetOutputPort()) mapper.SetInputConnection(cf.GetOutputPort()) # Start the UI Loop iren.Initialize() renwin.Render() iren.Start()
def DisplayNodalScalarsClip(self, vector):
try:
if len(vector) != len(self.node):
raise BaseException
except:
print "Input vector length does not length of nodes in class"
sys.exit()
myUnGrid = vtk.vtkUnstructuredGrid()
myPoints = vtk.vtkPoints()
myCells = vtk.vtkCellArray()
Tri = False
Tetra = False
#define pts
if len(self.node[0]) == 2:
Tri = True
else:
Tetra = True
if Tri == True:
#set pts
for coords in self.node:
myPoints.InsertNextPoint((coords[0], coords[1], 0.0))
#set Cells
for coords in self.elems:
myCells.InsertNextCell(3)
myCells.InsertCellPoint(coords[0])
myCells.InsertCellPoint(coords[1])
myCells.InsertCellPoint(coords[2])
myUnGrid.SetPoints(myPoints)
myUnGrid.SetCells(vtk.VTK_TRIANGLE, myCells)
if Tetra == True:
#set pts
for coords in self.node:
myPoints.InsertNextPoint((coords[0], coords[1], coords[2]))
#set Cells
for coords in self.elems:
myCells.InsertNextCell(4)
myCells.InsertCellPoint(coords[0])
myCells.InsertCellPoint(coords[1])
myCells.InsertCellPoint(coords[2])
myCells.InsertCellPoint(coords[3])
myUnGrid.SetPoints(myPoints)
myUnGrid.SetCells(vtk.VTK_TETRA, myCells)
#scalar
myScalars = vtk.vtkFloatArray()
myScalars.SetNumberOfComponents(1)
for i in range(0, len(vector)):
myScalars.InsertNextTuple1(vector[i])
myUnGrid.GetPointData().SetScalars(myScalars)
#clipping
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(0, 1, 0)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(plane)
clipper.SetInput(myUnGrid)
clipperMapper = vtk.vtkDataSetMapper()
clipperMapper.SetInputConnection(clipper.GetOutputPort())
clipperMapper.SetScalarRange(np.min(vector), np.max(vector))
clipperActor = vtk.vtkActor()
clipperActor.SetMapper(clipperMapper)
#colorbar
scalarBar = vtk.vtkScalarBarActor()
scalarBar.SetTitle("Scalar Values")
scalarBar.SetLookupTable(clipperMapper.GetLookupTable())
scalarBar.SetOrientationToVertical()
#position bar
pos = scalarBar.GetPositionCoordinate()
pos.SetCoordinateSystemToNormalizedViewport()
pos.SetValue(0.85, 0.05)
scalarBar.SetWidth(.1)
scalarBar.SetHeight(.95)
ren = vtk.vtkRenderer()
ren.AddActor(clipperActor)
ren.AddActor(scalarBar)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(300, 300)
renWin.Render()
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renWin)
interactor.Initialize()
interactor.Start()
Ids = vtk.vtkIdList() Ids.InsertNextId(0) Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Ids.InsertNextId(5) grid = vtk.vtkUnstructuredGrid() grid.Allocate(10, 10) grid.InsertNextCell(13, Ids) grid.SetPoints(Points) grid.GetPointData().SetScalars(Scalars) # Clip the wedge clipper = vtk.vtkClipDataSet() clipper.SetInputData(grid) clipper.SetValue(0.5) # build tubes for the triangle edges # wedgeEdges = vtk.vtkExtractEdges() wedgeEdges.SetInputConnection(clipper.GetOutputPort()) wedgeEdgeTubes = vtk.vtkTubeFilter() wedgeEdgeTubes.SetInputConnection(wedgeEdges.GetOutputPort()) wedgeEdgeTubes.SetRadius(.005) wedgeEdgeTubes.SetNumberOfSides(6) wedgeEdgeMapper = vtk.vtkPolyDataMapper() wedgeEdgeMapper.SetInputConnection(wedgeEdgeTubes.GetOutputPort()) wedgeEdgeMapper.ScalarVisibilityOff() wedgeEdgeActor = vtk.vtkActor()
center = output.GetCenter() sphere = vtk.vtkSphere() sphere.SetCenter(center) sphere.SetRadius(2.0) sphere2 = vtk.vtkSphere() sphere2.SetCenter(center[0] + 4.0, center[1], center[2]) sphere2.SetRadius(4.0) boolOp = vtk.vtkImplicitBoolean() boolOp.SetOperationTypeToUnion() boolOp.AddFunction(sphere) boolOp.AddFunction(sphere2) # clip the structured grid to produce a tetrahedral mesh clip = vtk.vtkClipDataSet() clip.SetInputData(output) clip.SetClipFunction(boolOp) clip.InsideOutOn() gf = vtk.vtkGeometryFilter() gf.SetInputConnection(clip.GetOutputPort()) clipMapper = vtk.vtkPolyDataMapper() clipMapper.SetInputConnection(gf.GetOutputPort()) clipActor = vtk.vtkActor() clipActor.SetMapper(clipMapper) outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(output)
Ids = vtk.vtkIdList() Ids.InsertNextId(0) Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Ids.InsertNextId(5) Ids.InsertNextId(6) Ids.InsertNextId(7) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(12, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) #Clip the hex clipper = vtk.vtkClipDataSet() clipper.SetInputData(Grid) clipper.SetValue(0.5) # build tubes for the triangle edges # tetEdges = vtk.vtkExtractEdges() tetEdges.SetInputConnection(clipper.GetOutputPort()) tetEdgeTubes = vtk.vtkTubeFilter() tetEdgeTubes.SetInputConnection(tetEdges.GetOutputPort()) tetEdgeTubes.SetRadius(.005) tetEdgeTubes.SetNumberOfSides(6) tetEdgeTubes.UseDefaultNormalOn() tetEdgeTubes.SetDefaultNormal(.577, .577, .577) tetEdgeMapper = vtk.vtkPolyDataMapper() tetEdgeMapper.SetInputConnection(tetEdgeTubes.GetOutputPort()) tetEdgeMapper.ScalarVisibilityOff()
edgePoints.InsertPoint(2, 0.5, 0.25, 0) edgeScalars = vtk.vtkFloatArray() edgeScalars.SetNumberOfTuples(3) edgeScalars.InsertValue(0, 0.0) edgeScalars.InsertValue(1, 0.0) edgeScalars.InsertValue(2, 0.9) aEdge = vtk.vtkQuadraticEdge() aEdge.GetPointIds().SetId(0, 0) aEdge.GetPointIds().SetId(1, 1) aEdge.GetPointIds().SetId(2, 2) aEdgeGrid = vtk.vtkUnstructuredGrid() aEdgeGrid.Allocate(1, 1) aEdgeGrid.InsertNextCell(aEdge.GetCellType(), aEdge.GetPointIds()) aEdgeGrid.SetPoints(edgePoints) aEdgeGrid.GetPointData().SetScalars(edgeScalars) edgeclips = vtk.vtkClipDataSet() edgeclips.SetInputData(aEdgeGrid) edgeclips.SetValue(0.5) aEdgeclipMapper = vtk.vtkDataSetMapper() aEdgeclipMapper.SetInputConnection(edgeclips.GetOutputPort()) aEdgeclipMapper.ScalarVisibilityOff() aEdgeMapper = vtk.vtkDataSetMapper() aEdgeMapper.SetInputData(aEdgeGrid) aEdgeMapper.ScalarVisibilityOff() aEdgeActor = vtk.vtkActor() aEdgeActor.SetMapper(aEdgeMapper) aEdgeActor.GetProperty().SetRepresentationToWireframe() aEdgeActor.GetProperty().SetAmbient(1.0) aEdgeclipActor = vtk.vtkActor() aEdgeclipActor.SetMapper(aEdgeclipMapper) aEdgeclipActor.GetProperty().BackfaceCullingOn()
