def addPlaneCutter(self, i):
#take record of the plane weight
planeWeightTextValue = self.planeWeightText[i].text()
self.planeWtInt[i] = planeWeightTextValue.toFloat()
self.ren.RemoveActor(self.planeActor)
plane=vtk.vtkPlane()
plane.SetOrigin(float(self.firstPlanePtValueRecord[i][0]),float(self.firstPlanePtValueRecord[i][1]), float(self.firstPlanePtValueRecord[i][2]) )
a = np.array([self.secondPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.secondPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1], self.secondPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]])
b = np.array([self.thirdPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.thirdPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1],self.thirdPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]])
self.planeOrigin[i] = self.firstPlanePtValueRecord[i]
self.planeNormal[i] = np.cross(a, b)
self.planeNormal[i] = self.planeNormal[i] / np.linalg.norm(self.planeNormal[i])
plane.SetNormal(self.planeNormal[i])
#create cutter
cutter=vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(self.append.GetOutputPort())
cutter.Update()
cutterMapper=vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(cutter.GetOutputPort())
self.planeActor.GetProperty().SetColor(1.0,1,0)
self.planeActor.GetProperty().SetLineWidth(2)
self.planeActor.SetMapper(cutterMapper)
self.ren.AddActor(self.planeActor)
def setClipPlanes(mapper, xmin, xmax, ymin, ymax):
clipPlaneCollection = vtk.vtkPlaneCollection()
if xmin != xmax:
clipPlaneXMin = vtk.vtkPlane()
clipPlaneXMin.SetOrigin(xmin, 0.0, 0.0)
clipPlaneXMin.SetNormal(1.0, 0.0, 0.0)
clipPlaneXMax = vtk.vtkPlane()
clipPlaneXMax.SetOrigin(xmax, 0.0, 0.0)
clipPlaneXMax.SetNormal(-1.0, 0.0, 0.0)
clipPlaneCollection.AddItem(clipPlaneXMin)
clipPlaneCollection.AddItem(clipPlaneXMax)
if ymin != ymax:
clipPlaneYMin = vtk.vtkPlane()
clipPlaneYMin.SetOrigin(0.0, ymin, 0.0)
clipPlaneYMin.SetNormal(0.0, 1.0, 0.0)
clipPlaneYMax = vtk.vtkPlane()
clipPlaneYMax.SetOrigin(0.0, ymax, 0.0)
clipPlaneYMax.SetNormal(0.0, -1.0, 0.0)
clipPlaneCollection.AddItem(clipPlaneYMin)
clipPlaneCollection.AddItem(clipPlaneYMax)
if clipPlaneCollection.GetNumberOfItems() > 0:
mapper.SetClippingPlanes(clipPlaneCollection)
def testPassByReference(self):
t = vtk.mutable(0.0)
p0 = (0.5, 0.0, 0.0)
n = (1.0, 0.0, 0.0)
p1 = (0.0, 0.0, 0.0)
p2 = (1.0, 1.0, 1.0)
x = [0.0, 0.0, 0.0]
vtk.vtkPlane.IntersectWithLine(p1, p2, n, p0, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
vtk.vtkPlane().IntersectWithLine(p1, p2, n, p0, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
t.set(0)
p = vtk.vtkPlane()
p.SetOrigin(0.5, 0.0, 0.0)
p.SetNormal(1.0, 0.0, 0.0)
p.IntersectWithLine(p1, p2, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
vtk.vtkPlane.IntersectWithLine(p, p1, p2, t, x)
self.assertEqual(round(t,6), 0.5)
self.assertEqual(round(x[0],6), 0.5)
self.assertEqual(round(x[1],6), 0.5)
self.assertEqual(round(x[2],6), 0.5)
def cut_brain_hemi(hemi_elec_data, hemi_poly_data):
depth_elec_data = hemi_elec_data[(hemi_elec_data.eType == 'D') | (hemi_elec_data.eType == 'd')]
print depth_elec_data
print
x_coords = np.array([avg_surf.x_snap for avg_surf in depth_elec_data.avgSurf], dtype=np.float)
y_coords = np.array([avg_surf.y_snap for avg_surf in depth_elec_data.avgSurf], dtype=np.float)
z_coords = np.array([avg_surf.z_snap for avg_surf in depth_elec_data.avgSurf], dtype=np.float)
x_min, x_max = np.min(x_coords), np.max(x_coords)
y_min, y_max = np.min(y_coords), np.max(y_coords)
z_min, z_max = np.min(z_coords), np.max(z_coords)
clipPlane = vtk.vtkPlane()
clipPlane.SetNormal(0.0, 0.0, 1.0)
# clipPlane.SetOrigin(0, 0, np.max(z_coords))
# clipPlane.SetOrigin(np.max(x_coords), np.max(y_coords), np.max(z_coords))
clipPlane.SetOrigin(0, 0, -500)
clipper = vtk.vtkClipPolyData()
clipper.SetInputData(hemi_poly_data)
clipper.SetClipFunction(clipPlane)
return clipper
def initialize (self):
debug ("In CutPlane::initialize ()")
self.plane = vtk.vtkPlane ()
self.fil = vtk.vtkCutter ()
out = self.prev_fil.GetOutput()
self.fil.SetInput (out)
self.fil.SetCutFunction (self.plane)
self.center = out.GetCenter ()
self.plane.SetOrigin (self.center)
self.plane.SetNormal (0.0, 0.0, 1.0)
self.step_var = Tkinter.DoubleVar ()
self.n_step_var = Tkinter.IntVar ()
self.resoln_var = Tkinter.DoubleVar ()
self.resoln_var.set (1.0)
self.slider = []
self.set_def_step_size ()
self.step_var.set (self.step_size)
self.n_step_var.set (10)
self.slider_pos = 0
self._auto_sweep_init ()
self.sweep_step.set (1)
self.fil.Update ()
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 testUnstructured(self):
rt = vtk.vtkRTAnalyticSource()
rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
t = vtk.vtkThreshold()
t.SetInputConnection(rt.GetOutputPort())
t.ThresholdByUpper(-10)
s = vtk.vtkSphere()
s.SetRadius(2)
s.SetCenter(0,0,0)
c = vtk.vtkTableBasedClipDataSet()
c.SetInputConnection(t.GetOutputPort())
c.SetClipFunction(s)
c.SetInsideOut(1)
c.Update()
self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
eg = vtk.vtkEnSightGoldReader()
eg.SetCaseFileName(VTK_DATA_ROOT + "/Data/EnSight/elements.case")
eg.Update()
pl = vtk.vtkPlane()
pl.SetOrigin(3.5, 3.5, 0.5)
pl.SetNormal(0, 0, 1)
c.SetInputConnection(eg.GetOutputPort())
c.SetClipFunction(pl)
c.SetInsideOut(1)
c.Update()
data = c.GetOutputDataObject(0).GetBlock(0)
self.assertEqual(data.GetNumberOfCells(), 75)
rw = vtk.vtkRenderWindow()
ren = vtk.vtkRenderer()
rw.AddRenderer(ren)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(data)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
ac = ren.GetActiveCamera()
ac.SetPosition(-7.9, 9.7, 14.6)
ac.SetFocalPoint(3.5, 3.5, 0.5)
ac.SetViewUp(0.08, 0.93, -0.34)
rw.Render()
ren.ResetCameraClippingRange()
rtTester = vtk.vtkTesting()
for arg in sys.argv[1:]:
rtTester.AddArgument(arg)
rtTester.AddArgument("-V")
rtTester.AddArgument("tableBasedClip.png")
rtTester.SetRenderWindow(rw)
rw.Render()
rtResult = rtTester.RegressionTest(10)
def create_cut_acto_plane(self,xpos,ypos,zpos,plane_id):
#vtk plane
plane=vtk.vtkPlane()
plane.SetOrigin(xpos,ypos,zpos)
if plane_id==0:
plane.SetNormal(1,0,0)
if plane_id==1:
plane.SetNormal(0,1,0)
if plane_id==2:
plane.SetNormal(0.0,0.0,1)
#create cutter
cutter=vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(self.dti_reader.GetOutputPort())
cutter.Update()
#probe filter for the cutting plane
probe_filter=vtk.vtkProbeFilter()
probe_filter.SetInputConnection(cutter.GetOutputPort())
probe_filter.SetSourceConnection(self.dti_reader.GetOutputPort())
self.plane1=plane
return probe_filter
def _Clip(self, pd):
# The plane implicit function will be >0 for all the points in the positive side
# of the plane (i.e. x s.t. n.(x-o)>0, where n is the plane normal and o is the
# plane origin).
plane = vtkPlane()
plane.SetOrigin(self.Iolet.Centre.x, self.Iolet.Centre.y, self.Iolet.Centre.z)
plane.SetNormal(self.Iolet.Normal.x, self.Iolet.Normal.y, self.Iolet.Normal.z)
# The sphere implicit function will be >0 for all the points outside the sphere.
sphere = vtkSphere()
sphere.SetCenter(self.Iolet.Centre.x, self.Iolet.Centre.y, self.Iolet.Centre.z)
sphere.SetRadius(self.Iolet.Radius)
# The VTK_INTERSECTION operator takes the maximum value of all the registered
# implicit functions. This will result in the function evaluating to >0 for all
# the points outside the sphere plus those inside the sphere in the positive
# side of the plane.
clippingFunction = vtkImplicitBoolean()
clippingFunction.AddFunction(plane)
clippingFunction.AddFunction(sphere)
clippingFunction.SetOperationTypeToIntersection()
clipper = vtkClipPolyData()
clipper.SetInput(pd)
clipper.SetClipFunction(clippingFunction)
# Filter to get part closest to seed point
connectedRegionGetter = vtkPolyDataConnectivityFilter()
connectedRegionGetter.SetExtractionModeToClosestPointRegion()
connectedRegionGetter.SetClosestPoint(*self.SeedPoint)
connectedRegionGetter.SetInputConnection(clipper.GetOutputPort())
connectedRegionGetter.Update()
return connectedRegionGetter.GetOutput()
def get(self):
resultado = {}
imageData = reader.get("IMAGE", self.subj, format="VTK", name=self.get_argument("type", None), space="world")
plane=vtk.vtkPlane()
if (self.get_argument("plane", None) == "x"):
plane.SetNormal(1,0,0)
plane.SetOrigin(float(self.get_argument("pos", None)),0,0)
if (self.get_argument("plane", None) == "y"):
plane.SetNormal(0,1,0)
plane.SetOrigin(0,float(self.get_argument("pos", None)),0)
if (self.get_argument("plane", None) == "z"):
plane.SetNormal(0,0,1)
plane.SetOrigin(0,0,float(self.get_argument("pos", None)))
planeCut = vtk.vtkCutter()
planeCut.SetInputData(imageData)
planeCut.SetCutFunction(plane)
planeCut.Update()
resultado['subject'] = self.subj
resultado['type'] = 'image'
resultado['plane'] = self.get_argument("plane", None)
resultado['pos'] = self.get_argument("pos", None)
resultado['bounds'] = planeCut.GetOutput().GetBounds()
resultado['dimensions'] = imageData.GetDimensions()
resultado['scalars'] = numpy_support.vtk_to_numpy(planeCut.GetOutput().GetPointData().GetScalars()).tolist()
self.set_header("Content-Type","application/json")
self.write(json.dumps(resultado, separators=(',',':')))
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 clipSurfacesForCutLVMesh(
endo,
epi,
height,
verbose=1):
myVTK.myPrint(verbose, "*** clipSurfacesForCutLVMesh ***")
plane = vtk.vtkPlane()
plane.SetNormal(0,0,-1)
plane.SetOrigin(0,0,height)
clip = vtk.vtkClipPolyData()
clip.SetClipFunction(plane)
clip.SetInputData(endo)
clip.Update()
clipped_endo = clip.GetOutput(0)
clip = vtk.vtkClipPolyData()
clip.SetClipFunction(plane)
clip.SetInputData(epi)
clip.Update()
clipped_epi = clip.GetOutput(0)
return (clipped_endo,
clipped_epi)
def InitVTKMethods(self): """Initializes the VTK methods to be used.""" self.colortable=ColorTableSource() self._plane=vtkPlane() self._cutter=vtkCutter() self._mapper=vtkDataSetMapper() self.actor=vtkLODActor()
def _fbzCutPlane(self, fbz, giaN, giaGlenoid):
"""Calculate cut-plane corresponding to fbz.
fbz is a list containing the two points defining a single FBZ
(forbidden zone). giaN is the glenoid-insertion axis normal.
giaGlenoid is the user-selected gia point on the glenoid.
This method will return a cut-plane to enforce the given fbz such
that giaGlenoid is on the inside of the implicit plane.
"""
fbzV = map(operator.sub, fbz[0], fbz[1])
fbzPN = [0,0,0]
vtk.vtkMath.Cross(fbzV, giaN, fbzPN)
vtk.vtkMath.Normalize(fbzPN)
fbzPlane = vtk.vtkPlane()
fbzPlane.SetOrigin(fbz[0])
fbzPlane.SetNormal(fbzPN)
insideVal = fbzPlane.EvaluateFunction(giaGlenoid)
if insideVal < 0:
# eeep, it's outside, so flip the planeNormal
fbzPN = [-1.0 * i for i in fbzPN]
fbzPlane.SetNormal(fbzPN)
return fbzPlane
def __init__(self, embryo, parent=None):
#super(vtkSimVisualizerCutter, self).__init__(embryo,parent)
vtkSimVisualizer.__init__(self,embryo,parent=parent)
# Check if 3D embryo
if self.embryo.geometry.dim==2:
printWarning("vtkSimVisualizerCutter does only work and make sense for 3D geometries. Will not initialize cutter and fall back tostandad vtkSimVisualizer.")
return
self.vtkWidgetCut,self.renCut,self.irenCut=self.initVTKWidget(self.frame)
# Plane used for cutting
self.plane = vtk.vtkPlane()
# Cutter
self.cutter = vtk.vtkCutter()
# Plane widget
self.initPlaneWidget()
# Add Layout
self.layout.addWidget(self.vtkWidgetCut,1,2)
# Run cut mesh once
self.CutMesh()
self.irenCut.Initialize()
def __init__(self, embryo, parent=None):
super(vtkSimVisualizerCutter, self).__init__(parent)
# Load embryo
self.embryo=embryo
# Check if simulation is saved
if len(self.embryo.simulation.vals)==0:
printWarning("Embryo does not have saved simulation. Rerun simulation with saveSim=True.")
# Check if 3D embryo
if self.embryo.geometry.dim==2:
printError("vtkSimVisualizerCutter does only work and make sense for 3D geometries. Use vtkSimVisualizer instead.")
# To numpy array
self.embryo.simulation.vals=np.array(self.embryo.simulation.vals)
# Frame
self.frame = QtGui.QFrame()
# Vtk widgets
self.vtkWidget,self.ren,self.iren=self.initVTKWidget(self.frame)
self.vtkWidgetCut,self.renCut,self.irenCut=self.initVTKWidget(self.frame)
# Add slider for 3D
self.slider,self.label=self.initSlider(0, len(self.embryo.simulation.tvecSim)-1,self.sliderCallback)
# Setup 3D simulation plot
self.init3D()
# Plane used for cutting
self.plane = vtk.vtkPlane()
# Cutter
self.cutter = vtk.vtkCutter()
# Plane widget
self.initPlaneWidget()
# Add Layout
self.layout=QtGui.QGridLayout()
self.layout.addWidget(self.vtkWidget,1,1)
self.layout.addWidget(self.vtkWidgetCut,1,2)
self.layout.addWidget(self.slider,2,1)
self.layout.addWidget(self.label,3,1)
# Set central widget
self.frame.setLayout(self.layout)
self.setCentralWidget(self.frame)
self.setWindowTitle('vtkSimVisualizerCutter of embryo ' + self.embryo.name)
# Run cut mesh once
self.CutMesh()
# Show everything
self.show()
self.iren.Initialize()
self.irenCut.Initialize()
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
#self.name = "Clipping Plane"
self.parent = parent
self.on = 0
self.renew = 1
self.currentPlane = None
self.clipped = 0
self.clippedModules = []
self.planeWidget = vtk.vtkPlaneWidget()
self.planeWidget.AddObserver("InteractionEvent", self.clipVolumeRendering)
self.planeWidget.SetResolution(20)
self.planeWidget.SetRepresentationToOutline()
self.planeWidget.NormalToXAxisOn()
self.renderer = self.parent.getRenderer()
self.plane = vtk.vtkPlane()
iactor = parent.wxrenwin.GetRenderWindow().GetInteractor()
self.planeWidget.SetInteractor(iactor)
VisualizationModule.__init__(self, parent, visualizer, **kws)
self.descs = {"ShowControl": "Show controls",
"AllModules": "Clip all modules",
"ClippedModule": "Module to clip"}
self.filterDesc = "Clip rendering using a plane"
def addContourObject(self, contourObject, prop3D):
"""Activate contouring for the contourObject. The contourObject
is usually a tdObject and specifically a vtkPolyData. We also
need the prop3D that represents this polydata in the 3d scene.
"""
if self._contourObjectsDict.has_key(contourObject):
# we already have this, thanks
return
try:
contourable = contourObject.IsA('vtkPolyData')
except:
contourable = False
if contourable:
# we need a cutter to calculate the contours and then a stripper
# to string them all together
cutter = vtk.vtkCutter()
plane = vtk.vtkPlane()
cutter.SetCutFunction(plane)
trfm = vtk.vtkTransform()
trfm.SetMatrix(prop3D.GetMatrix())
trfmFilter = vtk.vtkTransformPolyDataFilter()
trfmFilter.SetTransform(trfm)
trfmFilter.SetInput(contourObject)
cutter.SetInput(trfmFilter.GetOutput())
stripper = vtk.vtkStripper()
stripper.SetInput(cutter.GetOutput())
#
#tubef = vtk.vtkTubeFilter()
#tubef.SetNumberOfSides(12)
#tubef.SetRadius(0.5)
#tubef.SetInput(stripper.GetOutput())
# and create the overlay at least for the 3d renderer
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(stripper.GetOutput())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
c = self.sliceDirections.slice3dVWR._tdObjects.getObjectColour(
contourObject)
actor.GetProperty().SetColor(c)
actor.GetProperty().SetInterpolationToFlat()
# add it to the renderer
self.sliceDirections.slice3dVWR._threedRenderer.AddActor(actor)
# add all necessary metadata to our dict
contourDict = {'contourObject' : contourObject,
'contourObjectProp' : prop3D,
'trfmFilter' : trfmFilter,
'cutter' : cutter,
'tdActor' : actor}
self._contourObjectsDict[contourObject] = contourDict
# now sync the bugger
self.syncContourToObject(contourObject)
def cut(cube, normal):
plane=vtk.vtkPlane()
plane.SetOrigin(cube.GetCenter())
plane.SetNormal(*normal)
#create cutter
cutter=vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(cube.GetOutputPort())
cutter.Update()
cutterMapper=vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection( cutter.GetOutputPort())
#create plane actor
planeActor=vtk.vtkActor()
planeActor.GetProperty().SetColor(1.0,1,0)
planeActor.GetProperty().SetLineWidth(2)
planeActor.SetMapper(cutterMapper)
#create renderers and add actors of plane and cube
ren.AddActor(planeActor)
ret = []
points = cutter.GetOutput().GetPoints()
for i in range(points.GetNumberOfPoints()):
point = points.GetPoint(i)
ret.append( point )
return ret
def makePlaneClipper(vtkObj): """Makes a plane and clipper """ plane = vtk.vtkPlane() clipper = vtk.vtkClipDataSet() clipper.SetInputConnection(vtkObj.GetProducerPort()) clipper.SetClipFunction(plane) clipper.InsideOutOff() return clipper, plane
def planeToVTK(pp):
"""Create an equivalent vtkPlane object."""
vp = vtk.vtkPlane()
if pp.normal is not None:
vp.SetNormal(pp.normal)
if pp.centre is not None:
vp.SetOrigin(pp.centre)
return vp
def ExtractMesh(self):
meshExtractFilter = vtk.vtkExtractGeometry()
meshExtractFilter.SetInputData(self.Mesh)
meshExtractFilter.SetExtractInside(self.InsideOut)
clipPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(clipPlane)
meshExtractFilter.SetImplicitFunction(clipPlane)
meshExtractFilter.Update()
return meshExtractFilter.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 cutdataset(dataset, point, normal):
cutplane = vtk.vtkPlane()
cutplane.SetOrigin(point)
cutplane.SetNormal(normal)
cutter = vtk.vtkCutter()
cutter.SetInputData(dataset)
cutter.SetCutFunction(cutplane)
cutter.Update()
return cutter.GetOutput()
def CutMesh(self):
cutPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(cutPlane)
self.MeshCutFilter.SetCutFunction(cutPlane)
self.MeshCutFilter.Update()
self.Actor = vtk.vtkActor()
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(self.MeshCutFilter.GetOutputPort())
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
def __init__ (self, mod_m):
debug ("In CutPlaneModule::__init ()")
Module.__init__ (self, mod_m)
# this should be a vtkPlane
self.plane = vtk.vtkPlane ()
self.step_var = Tkinter.DoubleVar ()
self.n_step_var = Tkinter.IntVar ()
self.resoln_var = Tkinter.DoubleVar ()
self.resoln_var.set (1.0)
self.slider = []
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create cylinder
cylinder = vtk.vtkCylinder()
cylinder.SetCenter(0, 0, 0)
cylinder.SetRadius(1.0)
# Create plane
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(0, -1, 0)
# Cut the cylinder
cuted_cylinder = vtk.vtkImplicitBoolean()
cuted_cylinder.SetOperationTypeToIntersection()
#cuted_cylinder.SetOperationTypeToUnion()
cuted_cylinder.AddFunction(cylinder)
cuted_cylinder.AddFunction(plane)
# Sample
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(cuted_cylinder)
sample.SetModelBounds(-1.5 , 1.5 , -1.5 , 1.5 , -1.5 , 1.5)
sample.SetSampleDimensions(60, 60, 60)
sample.SetComputeNormals(0)
#
surface = vtk.vtkContourFilter()
#surface.SetInput(sample.GetOutput())
surface.SetInputConnection(sample.GetOutputPort())
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
#mapper.SetInput(surface.GetOutput())
mapper.SetInputConnection(surface.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def slicedataset(dataset, point, normal):
"""Slice through a vtkDataSet object with a plane defined by point and
normal."""
cutplane = vtk.vtkPlane()
cutplane.SetOrigin(point)
cutplane.SetNormal(normal)
cutter = vtk.vtkCutter()
cutter.SetInput(dataset)
cutter.SetCutFunction(cutplane)
cutter.Update()
return cutter.GetOutput()
def createCuttingPlane(self,normal,dimension): cuttingPlane = vtk.vtkPlane() #Set origin to the center of the data set so every slice makes contact cuttingPlane.SetOrigin(float(self.center[0]),float(self.center[1]),float(self.center[2])) cuttingPlane.SetNormal(float(normal['x']), float(normal['y']), float(normal['z'])) self.cutter = self.createCutter(cuttingPlane) self.outputPortForMapper = self.cutter.GetOutputPort() self.createMapper(False) self.createActor() rotationDegrees = 45 self.modifyActorForCuttingPlane(rotationDegrees) self.finalizePipeline()
def SetIolet(self, iolet):
self.iolet = iolet
plane = vtkPlane()
r = iolet.Centre
plane.SetOrigin(r.x, r.y, r.z)
n = iolet.Normal
plane.SetNormal(n.x, n.y, n.z)
self.cutter.SetCutFunction(plane)
self.regionPicker.SetClosestPoint(r.x, r.y, r.z)
return
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(15) sphere.SetThetaResolution(30) plane = vtk.vtkPlane() plane.SetNormal(1,0,0) cut = vtk.vtkCutter() cut.SetInputConnection(sphere.GetOutputPort()) cut.SetCutFunction(plane) cut.GenerateCutScalarsOn() strip = vtk.vtkStripper() strip.SetInputConnection(cut.GetOutputPort()) points = vtk.vtkPoints() points.InsertPoint(0,1,0,0) lines = vtk.vtkCellArray() lines.InsertNextCell(2) #number of points lines.InsertCellPoint(0) lines.InsertCellPoint(0) tip = vtk.vtkPolyData()
imageActor = vtk.vtkImageActor() imageActor.GetMapper().SetInputConnection(mapToColors.GetOutputPort()) imageActor.SetDisplayExtent(32, 32, 0, 63, 0, 92) #--------------------------------------------------------- # make a transform and some clipping planes transform = vtk.vtkTransform() transform.RotateWXYZ(-20, 0.0, -0.7, 0.7) volume.SetUserTransform(transform) bone.SetUserTransform(transform) imageActor.SetUserTransform(transform) c = volume.GetCenter() volumeClip = vtk.vtkPlane() volumeClip.SetNormal(0, 1, 0) volumeClip.SetOrigin(c[0], c[1], c[2]) boneClip = vtk.vtkPlane() boneClip.SetNormal(1, 0, 0) boneClip.SetOrigin(c[0], c[1], c[2]) volumeMapper.AddClippingPlane(volumeClip) boneMapper.AddClippingPlane(boneClip) #--------------------------------------------------------- ren.AddViewProp(volume) ren.AddViewProp(bone) ren.AddViewProp(imageActor)
def main():
colors = vtk.vtkNamedColors()
fileName, numberOfCuts = get_program_parameters()
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(fileName)
reader.Update()
bounds = reader.GetOutput().GetBounds()
print('Bounds:', ', '.join(['{:.3f}'.format(f) for f in bounds]))
plane = vtk.vtkPlane()
plane.SetOrigin((bounds[1] + bounds[0]) / 2.0, (bounds[3] + bounds[2]) / 2.0, bounds[4])
plane.SetNormal(0, 0, 1)
# Create cutter
high = plane.EvaluateFunction((bounds[1] + bounds[0]) / 2.0, (bounds[3] + bounds[2]) / 2.0, bounds[5])
cutter = vtk.vtkCutter()
cutter.SetInputConnection(reader.GetOutputPort())
cutter.SetCutFunction(plane)
cutter.GenerateValues(numberOfCuts, 0.99, 0.99 * high)
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputConnection(cutter.GetOutputPort())
cutterMapper.ScalarVisibilityOff()
# Create cut actor
cutterActor = vtk.vtkActor()
cutterActor.GetProperty().SetColor(colors.GetColor3d("Banana"))
cutterActor.GetProperty().SetLineWidth(2)
cutterActor.SetMapper(cutterMapper)
# Create model actor
modelMapper = vtk.vtkPolyDataMapper()
modelMapper.SetInputConnection(reader.GetOutputPort())
modelMapper.ScalarVisibilityOff()
modelActor = vtk.vtkActor()
modelActor.GetProperty().SetColor(colors.GetColor3d("Flesh"))
modelActor.SetMapper(modelMapper)
# Create renderers and add actors of plane and model
renderer = vtk.vtkRenderer()
renderer.AddActor(cutterActor)
renderer.AddActor(modelActor)
# Add renderer to renderwindow and render
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(600, 600)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderer.SetBackground(colors.GetColor3d("Burlywood"))
renderer.GetActiveCamera().SetPosition(0, -1, 0)
renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
renderer.GetActiveCamera().SetViewUp(0, 0, 1)
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.ResetCamera()
renderWindow.Render()
renderWindow.SetWindowName('CutWithCutFunction')
interactor.Start()
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.vtkTableBasedClipDataSet()
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('ClipUnstructuredGridWithPlane')
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 Execute(self):
from vmtk import vmtkscripts
if self.Surface == None:
self.PrintError('Error: no Surface.')
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputData(self.Surface)
triangleFilter.Update()
self.Surface = triangleFilter.GetOutput()
if self.Loop == None:
self.PrintError('Error: no Loop.')
select = vtk.vtkImplicitSelectionLoop()
select.SetLoop(self.Loop.GetPoints())
normal = [0.0, 0.0, 0.0]
centroid = [0.0, 0.0, 0.0]
vtk.vtkPolygon().ComputeNormal(self.Loop.GetPoints(), normal)
#compute centroid and check normals
p = [0.0, 0.0, 0.0]
for i in range(self.Loop.GetNumberOfPoints()):
p = self.Loop.GetPoint(i)
centroid[0] += p[0]
centroid[1] += p[1]
centroid[2] += p[2]
centroid[0] = centroid[0] / self.Loop.GetNumberOfPoints()
centroid[1] = centroid[1] / self.Loop.GetNumberOfPoints()
centroid[2] = centroid[2] / self.Loop.GetNumberOfPoints()
print("loop centroid", centroid)
locator = vtk.vtkPointLocator()
locator.SetDataSet(self.Surface)
locator.AutomaticOn()
locator.BuildLocator()
idsurface = locator.FindClosestPoint(centroid)
if (self.Surface.GetPointData().GetNormals() == None):
normalsFilter = vmtkscripts.vmtkSurfaceNormals()
normalsFilter.Surface = self.Surface
normalsFilter.NormalsArrayName = 'Normals'
normalsFilter.Execute()
self.Surface = normalsFilter.Surface
normalsurface = [0.0, 0.0, 0.0]
self.Surface.GetPointData().GetNormals().GetTuple(
idsurface, normalsurface)
print("loop normal: ", normal)
print("surface normal inside the loop: ", normalsurface)
check = vtk.vtkMath.Dot(normalsurface, normal)
if check < 0:
normal[0] = -normal[0]
normal[1] = -normal[1]
normal[2] = -normal[2]
#compute plane
proj = float(vtk.vtkMath.Dot(self.Loop.GetPoint(0), normal))
point = [0.0, 0.0, 0.0]
self.Loop.GetPoint(0, point)
for i in range(self.Loop.GetNumberOfPoints()):
tmp = vtk.vtkMath.Dot(self.Loop.GetPoint(i), normal)
if tmp < proj:
proj = tmp
self.Loop.GetPoint(i, point)
origin = [0.0, 0.0, 0.0]
origin[0] = point[0] #- normal[0]
origin[1] = point[1] #- normal[1]
origin[2] = point[2] #- normal[2]
plane = vtk.vtkPlane()
plane.SetNormal(normal[0], normal[1], normal[2])
plane.SetOrigin(origin[0], origin[1], origin[2])
#set bool
Bool = vtk.vtkImplicitBoolean()
Bool.SetOperationTypeToDifference()
Bool.AddFunction(select)
Bool.AddFunction(plane)
clipper = vtk.vtkClipPolyData()
clipper.SetInputData(self.Surface)
clipper.SetClipFunction(Bool)
clipper.GenerateClippedOutputOn()
clipper.InsideOutOff()
clipper.Update()
self.Surface = clipper.GetOutput()
def Main():
global continuousSize, continuousType, continuousData, contours, planeSource1s, planeSource2s, planeSource3s, plane1s, plane2s, plane3s, clipper1s, clipper2s, clipper3s, clipX, clipY, clipZ, lut
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
reader.Update()
print "gradientmag: %s" % sys.argv[2]
gmreader = vtk.vtkStructuredPointsReader()
gmreader.SetFileName(sys.argv[2])
gmreader.Update()
continuousSize = 0
continuousType = "HSV"
continuousData = []
print "params: %s" % sys.argv[3]
loadParamsFile(sys.argv[3])
clipX = 0
clipY = 0
clipZ = 0
r = reader.GetOutput().GetScalarRange()
datamin = r[0]
datamax = r[1]
for i in range(4, len(sys.argv)):
if sys.argv[i] == "--clip":
print "clip (%s,%s,%s)" % (sys.argv[i + 1], sys.argv[i + 2],
sys.argv[i + 3])
clipX = float(sys.argv[i + 1])
clipY = float(sys.argv[i + 2])
clipZ = float(sys.argv[i + 3])
clipperActors = []
planeSource1s = []
planeSource2s = []
planeSource3s = []
plane1s = []
plane2s = []
plane3s = []
clipper1s = []
clipper2s = []
clipper3s = []
for i in range(0, len(continuousData)):
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort())
contours.ComputeNormalsOn()
contours.SetValue(0, float(continuousData[i][0]))
planeSource1s.append(vtk.vtkPlaneSource())
planeSource1s[i].SetNormal(1, 0, 0)
planeSource1s[i].SetOrigin(clipX, 0, 0)
plane1s.append(vtk.vtkPlane())
plane1s[i].SetNormal(planeSource1s[i].GetNormal())
plane1s[i].SetOrigin(planeSource1s[i].GetOrigin())
clipper1s.append(vtk.vtkClipPolyData())
clipper1s[i].SetClipFunction(plane1s[i])
clipper1s[i].SetInputConnection(contours.GetOutputPort())
clipper1s[i].Update()
planeSource2s.append(vtk.vtkPlaneSource())
planeSource2s[i].SetNormal(0, 1, 0)
planeSource2s[i].SetOrigin(0, clipY, 0)
plane2s.append(vtk.vtkPlane())
plane2s[i].SetNormal(planeSource2s[i].GetNormal())
plane2s[i].SetOrigin(planeSource2s[i].GetOrigin())
clipper2s.append(vtk.vtkClipPolyData())
clipper2s[i].SetClipFunction(plane2s[i])
clipper2s[i].SetInputConnection(clipper1s[i].GetOutputPort())
clipper2s[i].Update()
planeSource3s.append(vtk.vtkPlaneSource())
planeSource3s[i].SetNormal(0, 0, 1)
planeSource3s[i].SetOrigin(0, 0, clipZ)
plane3s.append(vtk.vtkPlane())
plane3s[i].SetNormal(planeSource3s[i].GetNormal())
plane3s[i].SetOrigin(planeSource3s[i].GetOrigin())
clipper3s.append(vtk.vtkClipPolyData())
clipper3s[i].SetClipFunction(plane3s[i])
clipper3s[i].SetInputConnection(clipper2s[i].GetOutputPort())
clipper3s[i].Update()
probeFilter = vtk.vtkProbeFilter()
probeFilter.SetInputConnection(0, clipper3s[i].GetOutputPort())
probeFilter.SetInputConnection(1, gmreader.GetOutputPort())
probeFilter.Update()
gmrange = probeFilter.GetOutput().GetScalarRange()
gmin = gmrange[0]
gmax = gmrange[1]
gmclipper1 = vtk.vtkClipPolyData()
gmclipper1.SetInputConnection(probeFilter.GetOutputPort())
gmclipper1.InsideOutOff()
gmclipper1.SetValue(int(continuousData[i][1]))
gmclipper1.Update()
gmclipper2 = vtk.vtkClipPolyData()
gmclipper2.SetInputConnection(gmclipper1.GetOutputPort())
gmclipper2.InsideOutOn()
gmclipper2.SetValue(int(continuousData[i][2]))
gmclipper2.Update()
lut = vtk.vtkColorTransferFunction()
if continuousType == "HSV":
lut.SetColorSpaceToHSV()
p = continuousData[i]
print "Color: %s" % p
lut.AddHSVPoint(p[0], p[3], p[4], p[5])
elif continuousType == "RGB":
lut.SetColorSpaceToRGB()
p = continuousData[i]
print "Color: %s" % p
lut.AddRGBPoint(p[0], p[3], p[4], p[5])
clipperMapper = vtk.vtkPolyDataMapper()
clipperMapper.SetLookupTable(lut)
clipperMapper.SetInputConnection(gmclipper2.GetOutputPort())
clipperActors.append(vtk.vtkActor())
clipperActors[i].GetProperty().SetRepresentationToWireframe()
clipperActors[i].SetMapper(clipperMapper)
backFaces = vtk.vtkProperty()
backFaces.SetSpecular(0)
backFaces.SetDiffuse(0)
backFaces.SetAmbient(0)
backFaces.SetAmbientColor(1, 0, 0)
clipperActors[i].SetBackfaceProperty(backFaces)
lut_color = vtk.vtkColorTransferFunction()
for d in continuousData:
if continuousType == "HSV":
lut_color.SetColorSpaceToHSV()
lut_color.AddHSVPoint(d[0], d[3], d[4], d[5])
elif continuousType == "RGB":
lut_color.SetColorSpaceToRGB()
lut_color.AddRGBPoint(d[0], d[3], d[4], d[5])
colorMapper = vtk.vtkPolyDataMapper()
colorMapper.SetLookupTable(lut_color)
colorBar = vtkScalarBarActor()
colorBar.SetLookupTable(colorMapper.GetLookupTable())
colorBar.SetTitle("isovalue")
colorBar.SetNumberOfLabels(6)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.1)
colorBar.SetHeight(0.7)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
for i in range(0, len(clipperActors)):
clipperActors[i].GetProperty().SetOpacity(
continuousData[i][6]) # load opacity for actor
ren.AddActor(clipperActors[i])
ren.AddActor(colorBar)
# for depth peeling
ren.SetUseDepthPeeling(1)
ren.SetMaximumNumberOfPeels(2) # default 4
ren.SetOcclusionRatio(0.1) # default 0
ren.ResetCamera()
ren.SetBackground(0.2, 0.3, 0.4)
ren.ResetCameraClippingRange()
# for depth peeling
renWin.SetAlphaBitPlanes(1)
renWin.SetMultiSamples(0)
renWin.SetSize(1200, 600)
clipXSlider = vtk.vtkSliderRepresentation2D()
clipXSlider.SetMinimumValue(0)
clipXSlider.SetMaximumValue(300)
clipXSlider.SetValue(clipX)
clipXSlider.SetTitleText("X")
clipXSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint1Coordinate().SetValue(0.0, 0.3)
clipXSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint2Coordinate().SetValue(0.2, 0.3)
clipXSlider.SetSliderLength(0.02)
clipXSlider.SetSliderWidth(0.03)
clipXSlider.SetEndCapLength(0.01)
clipXSlider.SetEndCapWidth(0.03)
clipXSlider.SetTubeWidth(0.005)
clipXSlider.SetLabelFormat("%1.2lf")
clipXSlider.SetTitleHeight(0.02)
clipXSlider.SetLabelHeight(0.02)
SliderWidget2 = vtk.vtkSliderWidget()
SliderWidget2.SetInteractor(iren)
SliderWidget2.SetRepresentation(clipXSlider)
SliderWidget2.KeyPressActivationOff()
SliderWidget2.SetAnimationModeToAnimate()
SliderWidget2.SetEnabled(True)
SliderWidget2.AddObserver("InteractionEvent", clipXSliderHandler)
clipYSlider = vtk.vtkSliderRepresentation2D()
clipYSlider.SetMinimumValue(0)
clipYSlider.SetMaximumValue(300)
clipYSlider.SetValue(clipY)
clipYSlider.SetTitleText("Y")
clipYSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint1Coordinate().SetValue(0.0, 0.2)
clipYSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint2Coordinate().SetValue(0.2, 0.2)
clipYSlider.SetSliderLength(0.02)
clipYSlider.SetSliderWidth(0.03)
clipYSlider.SetEndCapLength(0.01)
clipYSlider.SetEndCapWidth(0.03)
clipYSlider.SetTubeWidth(0.005)
clipYSlider.SetLabelFormat("%1.2lf")
clipYSlider.SetTitleHeight(0.02)
clipYSlider.SetLabelHeight(0.02)
SliderWidget3 = vtk.vtkSliderWidget()
SliderWidget3.SetInteractor(iren)
SliderWidget3.SetRepresentation(clipYSlider)
SliderWidget3.KeyPressActivationOff()
SliderWidget3.SetAnimationModeToAnimate()
SliderWidget3.SetEnabled(True)
SliderWidget3.AddObserver("InteractionEvent", clipYSliderHandler)
clipZSlider = vtk.vtkSliderRepresentation2D()
clipZSlider.SetMinimumValue(0)
clipZSlider.SetMaximumValue(300)
clipZSlider.SetValue(clipZ)
clipZSlider.SetTitleText("Z")
clipZSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint1Coordinate().SetValue(0.0, 0.1)
clipZSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint2Coordinate().SetValue(0.2, 0.1)
clipZSlider.SetSliderLength(0.02)
clipZSlider.SetSliderWidth(0.03)
clipZSlider.SetEndCapLength(0.01)
clipZSlider.SetEndCapWidth(0.03)
clipZSlider.SetTubeWidth(0.005)
clipZSlider.SetLabelFormat("%1.2lf")
clipZSlider.SetTitleHeight(0.02)
clipZSlider.SetLabelHeight(0.02)
SliderWidget4 = vtk.vtkSliderWidget()
SliderWidget4.SetInteractor(iren)
SliderWidget4.SetRepresentation(clipZSlider)
SliderWidget4.KeyPressActivationOff()
SliderWidget4.SetAnimationModeToAnimate()
SliderWidget4.SetEnabled(True)
SliderWidget4.AddObserver("InteractionEvent", clipZSliderHandler)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def CuttingPlane(a, b, c):
N = PlaneNormal(a, b, c)
plane = vtk.vtkPlane()
plane.SetOrigin(a, 0, 0)
plane.SetNormal(*N)
return plane
