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 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 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 __init__(self):
"""Setup the pipeline.
"""
self.reader = vtkSTLReader()
self.cutter = vtkCutter()
self.cutter.SetInputConnection(self.reader.GetOutputPort())
self.regionPicker = vtkPolyDataConnectivityFilter()
self.regionPicker.SetInputConnection(self.cutter.GetOutputPort())
self.regionPicker.SetExtractionModeToClosestPointRegion()
self.scaler = vtkTransformPolyDataFilter()
self.scaler.SetInputConnection(self.regionPicker.GetOutputPort())
self.GetFileName = self.reader.GetFileName
self.SetFileName = self.reader.SetFileName
self.GetOutputPort = self.scaler.GetOutputPort
self.GetOutput = self.scaler.GetOutput
self.Update = self.scaler.Update
self.iolet = None
self.fileUnitLength = None
return
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 __init__ (self, mod_m):
debug ("In VectorCutPlane::__init__ ()")
Common.state.busy ()
Base.Objects.CutPlaneModule.__init__ (self, mod_m)
self.cut = vtk.vtkCutter ()
self.glyph2d_src = vtk.vtkGlyphSource2D ()
self.cone = vtk.vtkConeSource ()
self.arrow = vtk.vtkArrowSource ()
self.glyph_src = self.cone
self.glyph3d = vtk.vtkGlyph3D ()
self.mapper = self.map = vtk.vtkPolyDataMapper ()
self.actor = self.act = vtk.vtkActor ()
# used to orient the cone properly
self.glph_trfm = vtk.vtkTransformFilter ()
self.glph_trfm.SetTransform (vtk.vtkTransform ())
self.data_out = self.mod_m.GetOutput ()
# Point of glyph that is attached -- -1 is tail, 0 is center,
# 1 is head.
self.glyph_pos = -1
self.scale = 1.0
self.color_mode = 2 #2 is vector, 1 is scalar, -1 none
self._initialize ()
self._gui_init ()
self.renwin.Render ()
Common.state.idle ()
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 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 __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 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 ImplicitFunctionVtuCut(inputVtu, implicitFunction):
"""
Perform a cut of a vtu. Cutting as in ClipCow.py vtkCutter example of vtk
documentation 5.0.4, and Fluidity test case lock_exchange_tet.xml results
variable.
"""
# The cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(implicitFunction)
if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
cutter.SetInput(inputVtu.ugrid)
else:
cutter.SetInputData(inputVtu.ugrid)
# Cut
cutter.Update()
cutUPoly = cutter.GetOutput()
# Construct output
result = vtu()
result.ugrid = PolyDataToUnstructuredGrid(cutUPoly)
if result.ugrid.GetNumberOfPoints() == 0:
debug.deprint("Warning: Cut vtu contains no nodes")
return result
def AddDataSet(self, dataset, property):
doit = True
if not dataset:
doit = False
if self.HasDataSet(dataset):
doit = False
imagedata = vtk.vtkImageData.SafeDownCast(dataset)
if imagedata:
self.SetImage(imagedata)
else:
if not self.Image:
doit=False
if doit:
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(i, 3, 0)
matrix.SetElement(3, 3, 1)
cutter = vtk.vtkCutter()
cutter.SetCutFunction(self.DataSetCutPlane)
# Very strangely in some cases (ex : landmarks)
# the cutter increments the RefCount of the input dataset by 2
# making some memory leek...
# I could not manage to know what is wrong here
cutter.SetInput(dataset)
cutter.Update()
if not cutter.GetOutput():
print "Unable to cut this dataset..."
del matrix
del cutter
return None
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(cutter.GetOutput())
actor = vtk.vtkActor()
actor.SetUseMatrix(matrix)
actor.SetMapper(mapper)
if property:
actor.SetProperty(property)
actor.PickableOff()
self.AddActor(actor)
self.DataSetList.append(dataset)
self.DataSetActorList.append(actor)
self.ResetAndRestablishZoomAndCamera()
del actor
del mapper
del matrix
del cutter
return self.GetDataSetActor(dataset)
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 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 _UpdateIntersections(self):
if self._Planes is None:
return
if self._Cube is None:
return
self._Cutters = []
for plane in self._Planes:
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane.GetPlaneEquation())
cutter.SetInput(self._Cube.GetOutput())
self._Cutters.append(cutter)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self,
module_manager,
vtk.vtkCutter(),
"Processing.",
("vtkDataSet",),
("vtkPolyData",),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None,
)
def extract_sphere(data, origin, radius):
"""Extracts a spherical slice of data from VTK data object
"""
sphere = vtk.vtkSphere()
sphere.SetRadius(radius)
cutter = vtk.vtkCutter()
cutter.SetInputDataObject(data.reader.GetOutput())
cutter.SetCutFunction(sphere)
cutter.Update()
return cutter.GetOutputDataObject(0)
def _slice(pdi, pdo, plane):
"""Slice an input on a plane and produce the output
"""
# create slice
cutter = vtk.vtkCutter() # Construct the cutter object
cutter.SetInputData(pdi) # Use the grid as the data we desire to cut
cutter.SetCutFunction(plane) # the the cutter to use the plane we made
cutter.Update() # Perfrom the Cut
slc = cutter.GetOutput() # grab the output
pdo.ShallowCopy(slc)
return pdo
def __init__(self, map_actor, text_actor):
self.AddObserver("MouseMoveEvent", self.mouse_move_event)
self.map_actor = map_actor
self.text_actor = text_actor
self.elevation_actor = vtk.vtkActor()
self.sphere = vtk.vtkSphere()
self.cutter = vtk.vtkCutter()
self.stripper = vtk.vtkStripper()
self.tube_filter = vtk.vtkTubeFilter()
self.mapper = vtk.vtkDataSetMapper()
self.picker = vtk.vtkPointPicker()
def BuildView(self):
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
self.PlaneWidget = vtk.vtkImplicitPlaneWidget()
if self.Actor != None:
self.vmtkRenderer.Renderer.RemoveActor(self.Actor)
if self.Mesh != None:
self.MeshCutFilter = vtk.vtkCutter()
self.MeshCutFilter.SetInputData(self.Mesh)
cutPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(cutPlane)
self.MeshCutFilter.SetCutFunction(cutPlane)
self.MeshCutFilter.Update()
self.Surface = self.MeshCutFilter.GetOutput()
self.PlaneWidget.AddObserver("StartInteractionEvent",
self.StartPlaneCallback)
self.PlaneWidget.AddObserver("EndInteractionEvent",
self.EndPlaneCallback)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(self.Mesh)
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
self.Actor.GetProperty().SetOpacity(self.Opacity)
self.PlaneWidget.SetInteractor(
self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidget.SetPlaceFactor(1.25)
self.PlaneWidget.DrawPlaneOn()
self.PlaneWidget.GetPlaneProperty().SetOpacity(0.1)
self.PlaneWidget.SetProp3D(self.Actor)
self.PlaneWidget.PlaceWidget()
self.PlaneWidget.SetOrigin(self.Actor.GetCenter())
self.PlaneWidget.On()
if (self.Display == 1):
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def InitializeContours(self, data, color=yellow):
self.data = data
# Disable interactor
self.viewer.GetRenderWindow().GetInteractor().Disable()
if self.contourActor is not None:
self.viewer.GetRenderer().RemoveActor(self.contourActor)
self.contourActor = None
# Update contours
self.plane = vtk.vtkPlane()
RCW = self.viewer.GetResliceCursorWidget()
ps = RCW.GetResliceCursorRepresentation().GetPlaneSource()
self.plane.SetOrigin(ps.GetOrigin())
normal = ps.GetNormal()
self.plane.SetNormal(normal)
# Generate line segments
self.cutEdges = vtk.vtkCutter()
self.cutEdges.SetInputConnection(self.data.GetOutputPort())
self.cutEdges.SetCutFunction(self.plane)
self.cutEdges.GenerateCutScalarsOff()
self.cutEdges.SetValue(0, 0.5)
# Put together into polylines
cutStrips = vtk.vtkStripper()
cutStrips.SetInputConnection(self.cutEdges.GetOutputPort())
cutStrips.Update()
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputConnection(cutStrips.GetOutputPort())
# Attach observer to mapper
edgeMapper.AddObserver(vtk.vtkCommand.UpdateEvent, myCallback)
self.contourActor = vtk.vtkActor()
self.contourActor.SetMapper(edgeMapper)
prop = self.contourActor.GetProperty()
renderLinesAsTubes(prop)
prop.SetColor(color) # If Scalars are extracted - they turn green
# Move in front of image (is this necessary?)
transform = vtk.vtkTransform()
transform.Translate(normal)
self.contourActor.SetUserTransform(transform)
# Add actor to renderer
self.viewer.GetRenderer().AddViewProp(self.contourActor)
# Enable interactor again
self.viewer.GetRenderWindow().GetInteractor().Enable()
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 a sphere
sphere = vtk.vtkSphereSource()
sphere.SetRadius(50)
sphere.SetThetaResolution(100)
sphere.SetPhiResolution(100)
plane = vtk.vtkPlane()
plane.SetOrigin(20, 0, 0)
plane.SetNormal(1, 0, 0)
#create cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(sphere.GetOutputPort())
cutter.Update()
cutStrips = vtk.vtkStripper()
cutStrips.SetInputConnection(cutter.GetOutputPort())
cutStrips.Update()
cutPoly = vtk.vtkPolyData()
cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints())
cutPoly.SetPolys((cutStrips.GetOutput()).GetLines())
cutMapper = vtk.vtkPolyDataMapper()
cutMapper.SetInput(cutPoly)
#cutMapper.SetInputConnection(cutter.GetOutputPort())
cutActor = vtk.vtkActor()
cutActor.GetProperty().SetColor(1, 1, 0)
cutActor.GetProperty().SetEdgeColor(0, 1, 0)
cutActor.GetProperty().SetLineWidth(2)
cutActor.GetProperty().EdgeVisibilityOn()
cutActor.SetMapper(cutMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(cutActor)
self.ren.ResetCamera()
self._initialized = False
def InitializeContours(self, contourData, color=yellow):
# Disable interactor
self.viewer.GetRenderWindow().GetInteractor().Disable()
if self.contourActor is not None:
self.viewer.GetRenderer().RemoveActor(self.contourActor)
self.contourActor = None
# Update contours
self.plane = vtk.vtkPlane()
RCW = self.viewer.GetResliceCursorWidget()
ps = RCW.GetResliceCursorRepresentation().GetPlaneSource()
self.plane.SetOrigin(ps.GetOrigin())
normal = ps.GetNormal()
self.plane.SetNormal(normal)
# We ignore empty ouput (in C++)
# Transform polydata according to misplacement
self.transformPolyDataFilter = vtk.vtkTransformPolyDataFilter()
self.transformPolyDataFilter.SetInputConnection(
contourData.GetOutputPort())
self.transformPolyDataFilter.SetTransform(self.transform)
# Generate line segments
self.cutEdges = vtk.vtkCutter()
self.cutEdges.SetInputConnection(
self.transformPolyDataFilter.GetOutputPort())
self.cutEdges.SetCutFunction(self.plane)
self.cutEdges.GenerateCutScalarsOff()
self.cutEdges.SetValue(0, 0.5)
self.cutEdges.Update()
# Put together into polylines
self.cutStrips = vtk.vtkStripper()
self.cutStrips.SetInputConnection(self.cutEdges.GetOutputPort())
self.cutStrips.Update()
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputConnection(self.cutStrips.GetOutputPort())
self.contourActor = vtk.vtkActor()
self.contourActor.SetMapper(edgeMapper)
prop = self.contourActor.GetProperty()
renderLinesAsTubes(prop)
prop.SetColor(color)
# Add actor to renderer
self.viewer.GetRenderer().AddViewProp(self.contourActor)
# Enable interactor again
self.viewer.GetRenderWindow().GetInteractor().Enable()
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 a sphere
sphere = vtk.vtkSphereSource()
sphere.SetRadius(50)
sphere.SetThetaResolution(100)
sphere.SetPhiResolution(100)
plane = vtk.vtkPlane()
plane.SetOrigin(20, 0, 0)
plane.SetNormal(1, 0, 0)
#create cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(sphere.GetOutputPort())
cutter.Update()
cutStrips = vtk.vtkStripper()
cutStrips.SetInputConnection(cutter.GetOutputPort())
cutStrips.Update()
cutPoly = vtk.vtkPolyData()
cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints())
cutPoly.SetPolys((cutStrips.GetOutput()).GetLines())
cutMapper = vtk.vtkPolyDataMapper()
cutMapper.SetInput(cutPoly)
#cutMapper.SetInputConnection(cutter.GetOutputPort())
cutActor = vtk.vtkActor()
cutActor.GetProperty().SetColor(1, 1, 0)
cutActor.GetProperty().SetEdgeColor(0, 1, 0)
cutActor.GetProperty().SetLineWidth(2)
cutActor.GetProperty().EdgeVisibilityOn()
cutActor.SetMapper(cutMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(cutActor)
self.ren.ResetCamera()
self._initialized = False
def _createCutter(self):
logging.debug("In MultiSliceContour::createCutter()")
self._cutters = []
self._planeCutters = []
for slice in self._scene.slice:
cutter = vtk.vtkCutter()
plane = vtk.vtkPlane()
plane.SetOrigin(slice.plane.GetOrigin())
plane.SetNormal(slice.plane.GetNormal())
cutter.SetCutFunction(plane)
cutter.GenerateCutScalarsOn()
self._planeCutters.append(plane)
self._cutters.append(cutter)
def extract_plane(data, origin, normal):
"""Extracts a planar slice of data from VTK data object
"""
plane = vtk.vtkPlane()
plane.SetOrigin(*origin)
plane.SetNormal(*normal)
cutter = vtk.vtkCutter()
cutter.SetInputDataObject(data.reader.GetOutput())
cutter.SetCutFunction(plane)
cutter.Update()
return cutter.GetOutputDataObject(0)
def CreateSkinCutting(cf):
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(0, 0, 1)
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(cf.GetOutputPort())
for i in range(100):
cutter.SetValue(i, 10 * i)
cutter.Update()
return cutter
def slice_extraction(self, origin, normal):
# create a plane to cut (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
plane = vtk.vtkPlane()
plane.SetOrigin(*origin)
plane.SetNormal(*normal)
# create cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(self.mesh.GetOutputPort())
cutter.Update()
self.mesh = cutter
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 a cube
cube=vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
cubeMapper=vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
#create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
plane=vtk.vtkPlane()
plane.SetOrigin(10,0,0)
plane.SetNormal(1,0,0)
#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 cube actor
cubeActor=vtk.vtkActor()
cubeActor.GetProperty().SetColor(0.5,1,0.5)
cubeActor.GetProperty().SetOpacity(0.5)
cubeActor.SetMapper(cubeMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(planeActor)
self.ren.AddActor(cubeActor)
self.ren.ResetCamera()
self._initialized = False
def main():
colors = vtk.vtkNamedColors()
# Create a cube
cube = vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
# create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
plane = vtk.vtkPlane()
plane.SetOrigin(10, 0, 0)
plane.SetNormal(1, 0, 0)
# 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(colors.GetColor3d("Yellow"))
planeActor.GetProperty().SetLineWidth(2)
planeActor.SetMapper(cutterMapper)
# create cube actor
cubeActor = vtk.vtkActor()
cubeActor.GetProperty().SetColor(colors.GetColor3d("Aquamarine"))
cubeActor.GetProperty().SetOpacity(0.3)
cubeActor.SetMapper(cubeMapper)
# create renderers and add actors of plane and cube
ren = vtk.vtkRenderer()
ren.AddActor(planeActor)
ren.AddActor(cubeActor)
# Add renderer to renderwindow and render
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(600, 600)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.SetBackground(colors.GetColor3d("Silver"))
renWin.Render()
iren.Start()
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 a cube
cube = vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInputConnection(cube.GetOutputPort())
#create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
plane = vtk.vtkPlane()
plane.SetOrigin(10, 0, 0)
plane.SetNormal(1, 0, 0)
#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 cube actor
cubeActor = vtk.vtkActor()
cubeActor.GetProperty().SetColor(0.5, 1, 0.5)
cubeActor.GetProperty().SetOpacity(0.5)
cubeActor.SetMapper(cubeMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(planeActor)
self.ren.AddActor(cubeActor)
self.ren.ResetCamera()
self._initialized = False
def SetPlanes(self, planes):
self._Planes = planes
for i in range(3):
for j in range(i + 1, 3):
cutter = vtk.vtkCutter()
# VTK-6
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
cutter.SetInputData(planes[i].GetPolyData())
else:
cutter.SetInput(planes[i].GetPolyData())
cutter.SetCutFunction(planes[j].GetPlaneEquation())
self._Cutters.append(cutter)
def cutplanes(data, origin, normal):
# create cutting plane
plane = createplane(origin,normal)
# create cutter
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputData(data)
cutter.Update()
#print cutter
cutslice = cutter.GetOutput()
npoints = cutslice.GetNumberOfPoints()
ncells = cutslice.GetNumberOfCells()
#print cutslice
return cutslice, npoints, ncells
def __init__(self, mesh):
self.cutter = vtkCutter()
self.cutter.SetCutFunction(vtkPlane())
self.tubes = vtkTubeFilter()
self.tubes.SetInputConnection(self.cutter.GetOutputPort())
self.tubes.SetRadius(1)
self.tubes.SetNumberOfSides(8)
self.tubes.CappingOn()
self.mapper = vtkPolyDataMapper()
self.mapper.SetInputConnection(self.tubes.GetOutputPort())
self.actor = vtkActor()
self.actor.SetMapper(self.mapper)
self.cutter.SetInput(mesh)
self.AddPart(self.actor)
def vtkCutDataSet(dataset, func, values):
"""
uses vtkCutter,
always creates a mesh consisting only of triangles (in3d)
"""
f = vtk.vtkCutter()
f.SetCutFunction(func)
if not hasattr(values, '__iter__'):
values = [values]
for i, v in enumerate(values):
f.SetValue(i, v)
f.SetInput(dataset)
f.Update()
return f.GetOutput()
def __init__(self, mesh):
self.cutter = vtkCutter()
self.cutter.SetCutFunction(vtkPlane())
self.tubes = vtkTubeFilter()
self.tubes.SetInputConnection(self.cutter.GetOutputPort())
self.tubes.SetRadius(1)
self.tubes.SetNumberOfSides(8)
self.tubes.CappingOn()
self.mapper = vtkPolyDataMapper()
self.mapper.SetInputConnection(self.tubes.GetOutputPort())
self.actor = vtkActor()
self.actor.SetMapper(self.mapper)
self.cutter.SetInput(mesh)
self.AddPart(self.actor)
def BuildView(self):
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
self.PlaneWidget = vtk.vtkImplicitPlaneWidget()
if self.Actor != None:
self.vmtkRenderer.Renderer.RemoveActor(self.Actor)
if self.Mesh != None:
self.MeshCutFilter = vtk.vtkCutter()
self.MeshCutFilter.SetInputData(self.Mesh)
cutPlane = vtk.vtkPlane()
self.PlaneWidget.GetPlane(cutPlane)
self.MeshCutFilter.SetCutFunction(cutPlane)
self.MeshCutFilter.Update()
self.Surface = self.MeshCutFilter.GetOutput()
self.PlaneWidget.AddObserver("StartInteractionEvent",self.StartPlaneCallback)
self.PlaneWidget.AddObserver("EndInteractionEvent",self.EndPlaneCallback)
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(self.Mesh)
self.Actor = vtk.vtkActor()
self.Actor.SetMapper(mapper)
self.vmtkRenderer.Renderer.AddActor(self.Actor)
self.Actor.GetProperty().SetOpacity(self.Opacity)
self.PlaneWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidget.SetPlaceFactor(1.25)
self.PlaneWidget.DrawPlaneOn()
self.PlaneWidget.GetPlaneProperty().SetOpacity(0.1)
self.PlaneWidget.SetProp3D(self.Actor)
self.PlaneWidget.PlaceWidget()
self.PlaneWidget.SetOrigin(self.Actor.GetCenter())
self.PlaneWidget.On()
if (self.Display == 1):
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def __init__ (self, mod_m):
debug ("In WarpVectorCutPlane::__init__ ()")
Common.state.busy ()
Base.Objects.CutPlaneModule.__init__ (self, mod_m)
self.cut = vtk.vtkCutter ()
self.warp = vtk.vtkWarpVector ()
self.norm = vtk.vtkPolyDataNormals ()
self.mapper = self.map = vtk.vtkPolyDataMapper ()
self.map.SetLookupTable (self.mod_m.get_scalar_lut ())
self.actor = self.act = vtk.vtkActor ()
self.data_out = self.mod_m.GetOutput ()
self._initialize ()
self._gui_init ()
self.renwin.Render ()
Common.state.idle ()
def plot_mesh_cuts(pd, p_name, nz=7):
""" """
# Create a cube
cube = vtk.vtkCubeSource()
cube.SetXLength(40)
cube.SetYLength(30)
cube.SetZLength(20)
# cubeMapper = vtk.vtkPolyDataMapper()
# cubeMapper.SetInputConnection(cube.GetOutputPort())
pd.GetPointData().SetActiveScalars("radius") # for the the filter
tubeFilter = vtk.vtkTubeFilter()
tubeFilter.SetInputData(pd)
tubeFilter.SetNumberOfSides(9)
tubeFilter.SetVaryRadiusToVaryRadiusByAbsoluteScalar()
tubeFilter.Update()
bounds = pd.GetBounds()
planes = []
for i in range(0, nz): # z-slices (implicit functions)
p = vtk.vtkPlane()
z = ((bounds[5] - bounds[4]) / (nz + 1)) * (i + 1)
p.SetOrigin(0., 0., bounds[4] + z)
p.SetNormal(0., 0., 1)
planes.append(p)
lut = get_lookup_table(24) # 24= Brewer Diverging Brown-Blue-Green (11)
# lut.SetTableRange(pd.GetPointData().GetScalars(p_name).GetRange())
# create cutter, mappers, and actors
actors = []
for i in range(0, nz):
cutter = vtk.vtkCutter()
# cutter.SetInputData(pd)
cutter.SetCutFunction(planes[i])
cutter.SetInputConnection(tubeFilter.GetOutputPort())
cutter.Update()
m = vtk.vtkPolyDataMapper()
m.SetInputConnection(cutter.GetOutputPort())
m.Update()
m.SetLookupTable(lut)
a = vtk.vtkActor() # create plane actor
a.GetProperty().SetColor(1.0, 1, 0)
a.GetProperty().SetLineWidth(2)
a.SetMapper(m)
actors.append(a)
return actors
def check_if_filt_tri_inside_PD(tripts, mesh):
points1 =vtk.vtkPoints()
points1.InsertNextPoint (triangle_points[0])
points1.InsertNextPoint (triangle_points[1])
points1.InsertNextPoint (triangle_points[2])
triangle =vtk.vtkTriangle()
triangle.GetPointIds().SetId ( 0, 0 )
triangle.GetPointIds().SetId ( 1, 1 )
triangle.GetPointIds().SetId ( 2, 2 )
triangles = vtk.vtkCellArray()
triangles.InsertNextCell(triangle)
trianglePolyData =vtk.vtkPolyData()
trianglePolyData.SetPoints( points1 )
trianglePolyData.SetPolys( triangles )
A=triangle_points[0]
B=triangle_points[1]
C=triangle_points[2]
a_minus_b=A-B
a_minus_C=A-C
normtoplane=np.cross(a_minus_b,a_minus_C)
centerOfMassFilter =vtk.vtkCenterOfMass()
centerOfMassFilter.SetInputData(trianglePolyData)
centerOfMassFilter.Update()
center=centerOfMassFilter.GetCenter()
plane = vtk.vtkPlane()
plane.SetOrigin(center)
plane.SetNormal(normtoplane)
planeCut = vtk.vtkCutter()
planeCut.SetInputData(mesh)
planeCut.SetCutFunction(plane)
planeCut.Update()
num_inter= planeCut.GetOutput().GetNumberOfPoints()
return num_inter
def InitializeContour(self, data):
# Update contours
self.plane = vtk.vtkPlane()
RCW = self.viewer.GetResliceCursorWidget()
ps = RCW.GetResliceCursorRepresentation().GetPlaneSource()
normal = ps.GetNormal()
origin = ps.GetOrigin()
self.plane.SetOrigin(origin)
self.plane.SetNormal(normal)
if not oldWay:
self.plane.SetOrigin(0, 0, 0)
self.plane.SetNormal(0, 0, 1)
self.tmp = vtk.vtkTransform()
self.tmp.SetMatrix(
main_window.planeWidget[self.iDim].GetResliceAxes())
self.plane.SetTransform(self.tmp)
# Generate line segments
cutEdges = vtk.vtkCutter()
cutEdges.SetInputConnection(main_window.vesselNormals.GetOutputPort())
cutEdges.SetCutFunction(self.plane)
cutEdges.GenerateCutScalarsOff()
cutEdges.SetValue(0, 0.5)
# Put together into polylines
cutStrips = vtk.vtkStripper()
cutStrips.SetInputConnection(cutEdges.GetOutputPort())
cutStrips.Update()
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputConnection(cutStrips.GetOutputPort())
self.edgeActor = vtk.vtkActor()
self.edgeActor.SetMapper(edgeMapper)
prop = self.edgeActor.GetProperty()
renderLinesAsTubes(prop)
prop.SetColor(yellow) # If Scalars are extracted - they turn green
# Move in front of image
transform = vtk.vtkTransform()
transform.Translate(normal)
self.edgeActor.SetUserTransform(transform)
# Add actor to renderer
self.viewer.GetRenderer().AddViewProp(self.edgeActor)
def addSlices(self, slices):
r"""
Adds slices into the AmpActor which can then be rendered
Parameters
----------
slices: array_like
The values in the z-axis of which to make the slices
"""
self.planes = []
self.cutters = []
self.pMapper = []
self.pActors = []
self.lActors = []
self.labels = []
self.hier = []
self.lMapper = []
for s in slices:
p = vtk.vtkPlane()
p.SetOrigin(0, 0, s)
p.SetNormal(0, 0, 1)
c = vtk.vtkCutter()
c.SetCutFunction(p)
c.SetInputData(self.mesh)
c.Update()
cM=vtk.vtkPolyDataMapper()
cM.SetInputConnection(c.GetOutputPort())
pA=vtk.vtkActor()
pA.GetProperty().SetColor(31.0/255.0, 73.0/255.0, 125.0/255.0)
pA.GetProperty().SetLineWidth(5)
pA.GetProperty().SetInterpolationToFlat()
pA.GetProperty().EdgeVisibilityOn()
pA.GetProperty().SetRenderLinesAsTubes(True)
pA.SetMapper(cM)
text = vtk.vtkBillboardTextActor3D()
text.SetInput('test')
text.SetPosition(0,0,s)
text.GetTextProperty().SetColor(0, 0, 0)
self.planes.append(p)
self.cutters.append(c)
self.pMapper.append(cM)
self.pActors.append(pA)
self.lActors.append(text)
self.setOpacity(0.1)
def createClipActor(grid, plane, showScalar=False, range=None, showEdges=False, colorMap='GrayScale'):
clipMapper = vtk.vtkDataSetMapper()
clipMapper.SetInput(grid)
cutMapper = vtk.vtkDataSetMapper()
clipActor = vtk.vtkActor()
cutActor = vtk.vtkActor()
if showScalar:
scalars = grid.GetPointData().GetScalars()
if scalars==None:
scalars = grid.GetCellData().GetScalars()
if scalars==None:
scalars = grid.GetPointData().GetArray(0)
grid.GetPointData().SetScalars(scalars)
if scalars==None:
scalars = grid.GetCellData().GetArray(0)
grid.GetCellData().SetScalars(scalars)
if range==None: range = [scalars.GetRange()[0],.8*scalars.GetRange()[1]]
cutMapper.SetScalarRange(*range)
clipMapper.SetScalarRange(*range)
if colorMap=='GrayScale':wl = vtk.vtkWindowLevelLookupTable()
else:
wl = vtk.vtkLookupTable()
wl.SetScaleToLinear()
wl.SetRange(*range)
wl.SetHueRange(0.6667,0.0)#blue to red
wl.Build()
clipMapper.SetLookupTable(wl)
cutMapper.SetLookupTable(wl)
else:
clipMapper.ScalarVisibilityOff()
cutMapper.ScalarVisibilityOff()
clipActor.GetProperty().SetColor(.6, .6, .6)
cutActor.GetProperty().SetColor(.6, .6, .6)
clipMapper.AddClippingPlane(plane)
clipActor.SetMapper(clipMapper)
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInput(grid)
cutter.Update()
cutMapper.SetInputConnection(cutter.GetOutputPort())
cutActor.SetMapper(cutMapper)
if showEdges:
cutActor.GetProperty().EdgeVisibilityOn()
clipActor.GetProperty().EdgeVisibilityOn()
return [cutActor,clipActor]
def __init__(self, actCut, Map, text):
self.AddObserver("MouseMoveEvent", self.mouseMoveEvent)
# l'acteur dois déjà être ajouté au renderer
self.PickedActorCutter = actCut
self.Map = Map
self.textActor = text
self.plane = vtk.vtkPlane()
self.plane.SetNormal(0, 0, 1)
self.cutter = vtk.vtkCutter()
self.cutter.SetCutFunction(self.plane)
self.cutter.SetValue(0, 10)
self.cutter.SetInputData(self.Map)
self.cutterMapper = vtk.vtkPolyDataMapper()
def sliceheart(domain, C, N, verbose=True):
if (verbose): print '*** Slice Heart ***'
plane = vtk.vtkPlane()
plane.SetOrigin(C)
plane.SetNormal(N)
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
if (vtk.vtkVersion().GetVTKMajorVersion() < 6):
cutter.SetInput(domain)
else:
cutter.SetInputData(domain)
cutter.Update()
return cutter.GetOutput()
def getSlice(data_outVTK, orig, nor):
"""
Defines the plane normal to the vector *nor* that contains the point *orig*
and then extract the data from the reader *reader*. The dimension of the data
returned is reduced by one (a 2D data field gives a 1D data filed).
Parameters
----------
data_outVTK : VTK output object from a VTK reader
VTK output object associated to the file we want to extract a slice of data.
orig : tuple(3)
A point element of the plane used to slice the data.
normal : tuple(3)
A vector normal to the plane used to slice the data.
Returns
-------
slice_outVTK : VTK output object from a VTK reader
Returned data are still not in an array form, but a VTK output object
is returned where the data are stored.
"""
#function display
print '---- DAEPy::getSlice ----'
# Plane of the Slice
plane = vtk.vtkPlane()
plane.SetOrigin(orig)
plane.SetNormal(nor)
print '--> normal used to slice: ', nor
# Cutter plane
planeCut = vtk.vtkCutter()
# planeCut.SetInputData(data_outVTK) # VTK6 SetInput() repl. with SetInputData() vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput
planeCut.SetInput(data_outVTK) # sometimes to switch one another
planeCut.SetCutFunction(plane)
# Make the slice
planeCut.Update()
slice_outVTK = planeCut.GetOutput()
print ''
return slice_outVTK
def testCutterNoTriangles(self):
cutter = vtk.vtkCutter()
cutter.GenerateTrianglesOff() # triangle generation is disabled!
cutter_function = vtk.vtkPlane()
cutter_function.SetOrigin(0.0, 0.0, 0.5)
cutter_function.SetNormal(0.0, 0.0, 1.0)
cutter.SetCutFunction(cutter_function)
cutter.SetInputData(self.vtk_grid)
cutter.Update()
surface = cutter.GetOutput()
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputData(surface)
writer.SetFileName('surface_poly.vtp')
writer.Write()
self.assertEqual(surface.GetNumberOfCells(), 1)
def get_section(asmesh: vtk.vtkPolyData,
normal,
origin,
return_untransformed=False):
normal = normal / np.linalg.norm(normal)
cutter = vtk.vtkCutter()
plane = vtk.vtkPlane()
plane.SetOrigin(origin)
plane.SetNormal(normal)
cutter.SetCutFunction(plane)
cutter.SetInputData(asmesh)
cutter.Update()
cut = pyvista.PolyData(cutter.GetOutput())
lines = extract_lines(cut)
if return_untransformed:
return [np.array(cut.points[l]) for l in lines]
# we need to apply a transform to put the data in the local section reference frame
# we start setting the new axis for building the transform
z = -normal
u = np.array([
1, 0, 0.0
]) # as x we will use the vector coming from projecting u onto the plane
u = u / np.linalg.norm(u)
x = u - u.dot(
normal) * normal # note: we know they already are unit vectors
y = np.cross(z, x) # third axis
T = np.column_stack([x, y, z]) # note we know transform is orthonormal
newpts = cut.points.dot(T)
o = []
for sline in lines:
aa = newpts[:, :2][sline]
o.append(np.array(aa))
return o
def write_unstructured_grid(filename,mesh,cdata,nEle,EFs,time,verbose,
outline=False,cut=[]):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
## writer.SetDataModeToAscii()
writer.SetFileName(filename+'.vtu')
extract = vtk.vtkExtractCells()
extract.SetInputData(mesh)
eleList = vtk.vtkIdList()
EF = cdata.GetArray('EF')
for k in range(nEle):
if (EFs[EF.GetValue(k)][0]<time and EFs[EF.GetValue(k)][1]>=time) or (EFs[EF.GetValue(k)][0]==0 and time==0):
a=eleList.InsertNextId(k)
extract.SetCellList(eleList)
grid = extract.GetOutputPort()
if outline:
gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(grid)
cpd = vtk.vtkCleanPolyData()
cpd.SetInputConnection(gf.GetOutputPort())
cpd.Update()
af = vtk.vtkAppendFilter()
af.AddInputData(cpd.GetOutput())
grid = af.GetOutputPort()
elif len(cut):
plane = vtk.vtkPlane()
plane.SetOrigin(cut[0])
plane.SetNormal(cut[1])
cutter = vtk.vtkCutter()
cutter.SetInputConnection(grid)
cutter.SetCutFunction(plane)
cutter.Update()
cpd = vtk.vtkCleanPolyData()
cpd.SetInputConnection(cutter.GetOutputPort())
cpd.Update()
af = vtk.vtkAppendFilter()
af.AddInputData(cpd.GetOutput())
grid = af.GetOutputPort()
writer.SetFileName(filename+'_cut.vtu')
writer.SetInputConnection(grid)
writer.Write()
if not verbose:
print('%i elements written to %s'%(eleList.GetNumberOfIds(),filename))
def __init__(self, marker, planeWidget,
transform=None, lineWidth=1):
self.lineWidth=lineWidth
self.marker = marker
self.markerSource = marker.get_source()
self.planeWidget = planeWidget
self.transform = transform
self.implicitPlane = vtk.vtkPlane()
self.ringEdges = vtk.vtkCutter()
self.ringStrips = vtk.vtkStripper()
self.ringPoly = vtk.vtkPolyData()
self.ringMapper = vtk.vtkPolyDataMapper()
self.ringEdges.SetInput(self.markerSource.GetOutput())
self.implicitPlane.SetNormal(self.planeWidget.GetNormal())
self.implicitPlane.SetOrigin(self.planeWidget.GetOrigin())
#print 'implicit plane', self.implicitPlane
self.ringEdges.SetCutFunction(self.implicitPlane)
self.ringEdges.GenerateCutScalarsOff()
self.ringEdges.SetValue(0, 0.0)
self.ringStrips.SetInput(self.ringEdges.GetOutput())
self.ringStrips.Update()
self.ringPoly.SetPoints(self.ringStrips.GetOutput().GetPoints())
self.ringPoly.SetPolys(self.ringStrips.GetOutput().GetLines())
self.ringMapper.SetInput(self.ringPoly)
self.SetMapper(self.ringMapper)
self.lineProperty = self.GetProperty()
self.lineProperty.SetRepresentationToWireframe()
self.lineProperty.SetAmbient(1.0)
self.lineProperty.SetColor(self.marker.get_color())
self.lineProperty.SetLineWidth(lineWidth)
self.SetProperty(self.lineProperty)
self.VisibilityOff()
if transform is not None:
self.filter = vtk.vtkTransformPolyDataFilter()
self.filter.SetTransform(transform)
else:
self.filter = None
self.update()
def Slice_VTK_data_to_numpyArray(inputFileName, point, normal, resolution):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(inputFileName)
reader.Update()
plane = vtk.vtkPlane()
plane.SetOrigin(point)
plane.SetNormal(normal)
cutter = vtk.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(reader.GetOutputPort())
cutter.Update()
vtkarray = cutter.GetOutput().GetPointData().GetArray(0)
numpy_array = npvtk.vtk_to_numpy(vtkarray)
return numpy_array
def slice(dataset, normal='x', origin=None, generate_triangles=False,
contour=False):
"""Slice a dataset by a plane at the specified origin and normal vector
orientation. If no origin is specified, the center of the input dataset will
be used.
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 slice occurs
generate_triangles: bool, optional
If this is enabled (``False`` by default), the output will be
triangles otherwise, the output will be the intersection polygons.
contour : bool, optional
If True, apply a ``contour`` filter after slicing
"""
if isinstance(normal, str):
normal = NORMALS[normal.lower()]
# find center of data if origin not specified
if origin is None:
origin = dataset.center
if not is_inside_bounds(origin, dataset.bounds):
raise AssertionError('Slice is outside data bounds.')
# create the plane for clipping
plane = _generate_plane(normal, origin)
# create slice
alg = vtk.vtkCutter() # Construct the cutter object
alg.SetInputDataObject(dataset) # Use the grid as the data we desire to cut
alg.SetCutFunction(plane) # the the cutter to use the plane we made
if not generate_triangles:
alg.GenerateTrianglesOff()
alg.Update() # Perfrom the Cut
output = _get_output(alg)
if contour:
return output.contour()
return output
def Execute(self):
plane = vtk.vtkPlane()
plane.SetOrigin(self.Center)
plane.SetNormal(-math.sin(self.RotationAngle),math.cos(self.RotationAngle),0.0)
cutter = vtk.vtkCutter()
cutter.SetInput(self.Contour)
cutter.SetCutFunction(plane)
cutter.SetValue(0,0.0)
cutter.Update()
cutPoints = cutter.GetOutput().GetPoints()
if not cutPoints or cutPoints.GetNumberOfPoints()==0:
self.Locations = [0.0, 0.0]
self.Thickness = 0.0
self.Thickness3D = 0.0
return
self.Locations = self.FindLocations(cutPoints)
self.Thickness = self.Locations[1] - self.Locations[0]
self.Thickness3D = self.Thickness * math.cos(self.TiltingAngle)
def makeZCutter(self, bounds, scaleFactor, value):
""" create z cutter plane """
npos = self._calculateZCutterPos(value)
self.zplane = vtk.vtkPlane()
self.zplane.SetOrigin(0, 0, npos)
self.zplane.SetNormal(0, 0, 1)
self.ZCutter = vtk.vtkCutter()
self.ZCutter.SetInputConnection(self.warp.GetOutputPort())
self.ZCutter.SetCutFunction(self.zplane)
self.ZCutter.GenerateCutScalarsOff()
self.ZCutterMapper = vtk.vtkPolyDataMapper()
self.ZCutterMapper.SetInputConnection(self.ZCutter.GetOutputPort())
# visual plane to move
plane = vtk.vtkPlaneSource()
plane.SetResolution(50, 50)
plane.SetCenter(0, 0, 0)
plane.SetNormal(0, 0, 1)
tran = vtk.vtkTransform()
tran.Translate((bounds[1] - bounds[0]) / 2. - (0 - bounds[0]), (bounds[3] - bounds[2]) / 2. - (0 - bounds[2]),
npos)
tran.Scale((bounds[1] - bounds[0]), (bounds[3] - bounds[2]), 1)
tran.PostMultiply()
self.ZCutterTransform = tran
tranf = vtk.vtkTransformPolyDataFilter()
tranf.SetInputConnection(plane.GetOutputPort())
tranf.SetTransform(tran)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(tranf.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(0.9, 0.9, 0.9)
actor.GetProperty().SetOpacity(self.opacitySlice)
return actor
def __init__(self, item_actor, plane, lut):
self.cutter = vtkCutter()
self.cutter.SetCutFunction(plane)
self.cutter.SetInputConnection(item_actor.reader.GetOutputPort())
self.cutter.Update()
self.mapper = vtkDataSetMapper()
self.mapper.ScalarVisibilityOn()
self.mapper.SetLookupTable(lut)
self.mapper.SetInputConnection(self.cutter.GetOutputPort())
back = vtkProperty()
back.SetColor(100, 100, 100)
self.GetProperty().SetColor(1, 0, 0)
self.GetProperty().EdgeVisibilityOff()
self.GetProperty().SetLineWidth(3)
self.SetMapper(self.mapper)
self.SetBackfaceProperty(back)
def add_contour(renderer,
plane,
polydata,
transform=None,
line_width=3,
color=(1, 0, 0)):
"""Add contour of mesh cut by given image plane to render scene."""
if transform:
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInputData(polydata)
transformer.SetTransform(transform)
transformer.Update()
polydata = deep_copy(transformer.GetOutput())
transformer = None
cutter = vtk.vtkCutter()
cutter.SetInputData(polydata)
cutter.SetCutFunction(plane)
cutter.Update()
contour = deep_copy(cutter.GetOutput())
cutter = None
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(contour)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
prop = actor.GetProperty()
prop.LightingOff()
prop.SetRepresentationToWireframe()
prop.SetLineWidth(line_width)
if color:
prop.SetColor(color)
mapper.ScalarVisibilityOff()
elif polydata.GetPointData().GetScalars():
mapper.SetScalarModeToUsePointData()
mapper.ScalarVisibilityOn()
elif polydata.GetCellData().GetScalars():
mapper.SetScalarModeToUseCellData()
mapper.ScalarVisibilityOn()
renderer.AddActor(actor)
return actor
def slicevtkcontour(vtkmesh, h, init=0, end=0):
# Get limits
xmin, xmax, ymin, ymax, zmin, zmax = vtkmesh.GetBounds()
zmin += init
zmax -= end
# Plane to cut
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, zmin + h / 2.0)
plane.SetNormal(0, 0, 1)
# Cut function
cutter = vtk.vtkCutter()
cutter.SetInput(vtkmesh)
cutter.SetCutFunction(plane)
cutter.GenerateCutScalarsOn()
cutter.SetValue(0, 0)
# Catch the points
cutStrips = vtk.vtkStripper()
cutStrips.SetInputConnection(cutter.GetOutputPort())
cutStrips.Update()
# Slice and create polygons
layers = list()
# zreal = h/2.0
z = zmin + h / 2.0 # because set an reliable zero can broke the tip
zs = list()
polygons = list() # one for layer
while z < zmax:
zs.append(z)
plane.SetOrigin(0, 0, z)
cutStrips.Update()
coords = tuple()
for j in range(
cutStrips.GetOutput().GetCell(0).GetPoints().GetNumberOfPoints()
): # retrieve all points from the line
vec = Vec(cutStrips.GetOutput().GetCell(0).GetPoints().GetPoint(j))
coords += ((vec.x, vec.y),)
polygon = Polygon(coords)
polygons.append(polygon)
z += h
return polygons, zs
def SliceSurface(self, m_pt, m_normalVector):
"""
Use vtkCutter to obtain a slice along the centerline direction
:param m_pt: [float, float, float] A coordinate on the desired cutting plane
:param m_normalVector: [float, float, float] The normal vector of the cutting plane
:return:
"""
m_plane = vtk.vtkPlane()
m_plane.SetOrigin(m_pt)
m_plane.SetNormal(m_normalVector)
# create cutter
m_cutter = vtk.vtkCutter()
m_cutter.SetCutFunction(m_plane)
m_cutter.SetInputConnection(self._reader.GetOutputPort())
m_cutter.Update()
m_vtkpoints = m_cutter.GetOutput().GetPoints()
return m_vtkpoints
