def add_stud(prev, x, y):
cylA = create_cylinder(r=2.5, h=2.)
trA = vtk.vtkTransform()
trA.Translate(x, y, 10.6)
trA.RotateX(90)
tfA = vtk.vtkTransformPolyDataFilter()
tfA.SetTransform(trA)
tfA.SetInputConnection(cylA.GetOutputPort())
bA = vtkboolPython.vtkPolyDataBooleanFilter()
bA.SetInputConnection(prev.GetOutputPort())
bA.SetInputConnection(1, tfA.GetOutputPort())
bA.SetOperModeToUnion()
bA.DecPolysOff()
cylB = create_cylinder(r=1.5, h=1.)
trB = vtk.vtkTransform()
trB.Translate(x, y, 9.1)
trB.RotateX(90)
tfB = vtk.vtkTransformPolyDataFilter()
tfB.SetTransform(trB)
tfB.SetInputConnection(cylB.GetOutputPort())
bB = vtkboolPython.vtkPolyDataBooleanFilter()
bB.SetInputConnection(bA.GetOutputPort())
bB.SetInputConnection(1, tfB.GetOutputPort())
bB.SetOperModeToDifference()
bB.DecPolysOff()
return bB
def Merge5 ():
reader = vtk.vtkPolyDataReader()
reader.SetFileName('test10.vtk')
reader2 = vtk.vtkPolyDataReader()
reader2.SetFileName('test12.vtk')
reader3 = vtk.vtkPolyDataReader()
reader3.SetFileName('test13.vtk')
app = vtk.vtkAppendPolyData()
app.AddInputConnection(reader.GetOutputPort())
tr = vtk.vtkTransform()
tr.Translate(-50.916666, -1.083333, 0)
tr.RotateZ(90)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(tr)
tp.SetInputConnection(reader2.GetOutputPort())
app.AddInputConnection(tp.GetOutputPort())
tr2 = vtk.vtkTransform()
tr2.Translate(-50.916666, -1.083333, 0)
tp2 = vtk.vtkTransformPolyDataFilter()
tp2.SetTransform(tr2)
tp2.SetInputConnection(reader3.GetOutputPort())
app.AddInputConnection(tp2.GetOutputPort())
return app
def __init__(self):
EventHandler.EventHandler.__init__(self)
# default name is the class name, minus the "Factory"
self._Name = self.__class__.__name__
if self._Name[-7:] == 'Factory':
self._Name = self._Name[0:-7]
# Store the modified time
self._MTime = vtk.vtkObject()
self._RenderTime = vtk.vtkObject()
# list of renderers the actors are displayed in
self._Renderers = []
# dictionary of actors for each renderer
self._ActorDict = {}
# ActorFactories which are children of this one
self._Children = []
# the transform for all of the actors
self._Transform = vtk.vtkTransform()
# this transform is used as a spare
self._DummyTransform = vtk.vtkTransform()
def __init__(self):
# ODE initialization
self.world = ode.World()
self.world.setGravity(GRAVITY)
self.world.setERP(ERP)
self.world.setCFM(CFM)
self.space = ode.Space()
self.floor = ode.GeomPlane(self.space, (0.0,1.0,0.0), 0.0)
self.jointGroup = ode.JointGroup()
self.time = 0.0
# VTK initialization
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(102.0/255.0,204/255.0,1.0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(WINDOW_WIDTH,WINDOW_HEIGHT)
self.window.AddRenderer(self.renderer)
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetRenderWindow(self.window)
self.axes = vtk.vtkAxesActor()
self.axes.SetAxisLabels(0)
transform = vtk.vtkTransform()
transform.Scale(0.1,0.1,0.1)
self.axes.SetUserTransform(transform)
self.renderer.AddActor(self.axes)
# Create ground plane visualization
self.floorVisual = vtk.vtkPlaneSource()
self.floorVisual.SetNormal((0.0,1.0,0.0))
self.floorVisual.SetResolution(10,10)
self.floorReader = vtk.vtkJPEGReader()
self.floorReader.SetFileName(FLOOR_IMAGE)
self.floorTexture = vtk.vtkTexture()
transform = vtk.vtkTransform()
transform.Scale(50.0,50.0,50.0)
self.floorTexture.SetTransform(transform)
self.floorTexture.SetInput(self.floorReader.GetOutput())
self.floorMap = vtk.vtkTextureMapToPlane()
self.floorMap.SetInput(self.floorVisual.GetOutput())
self.floorMapper = vtk.vtkPolyDataMapper()
self.floorMapper.SetInput(self.floorMap.GetOutput())
self.floorActor = vtk.vtkActor()
transform = vtk.vtkTransform()
transform.Scale(100.0,100.0,100.0)
self.floorActor.SetUserTransform(transform)
self.floorActor.SetMapper(self.floorMapper)
self.floorActor.SetTexture(self.floorTexture)
self.renderer.AddActor(self.floorActor)
# VTK camera setup
self.camera = vtk.vtkCamera()
self.renderer.SetActiveCamera(self.camera)
self.cameraFocus = [0.0, 0.0, 0.0]
self.cameraPos = [4.0, 2.5, 1.5]
self.cameraOffset = [0.0,1.0,3.0]
self.cameraRoll = 0.0
# Keep track of the simulated bodies and robots
self.bodies = []
self.robots = []
self.controllers = []
def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def DeformSurface(self):
# interpolate and sample the displacement norms over the surface
rbf = vtkvmtkcontrib.vtkvmtkRBFInterpolation2()
rbf.SetSource(self.SourceSpheres)
rbf.SetRBFTypeToBiharmonic()
rbf.ComputeCoefficients()
sampler = vtkvmtkcontrib.vtkvmtkPolyDataSampleFunction()
sampler.SetInput(self.Surface)
sampler.SetImplicitFunction(rbf)
sampler.SetSampleArrayName("DisplacementNorms")
sampler.Update()
sampArray = sampler.GetOutput().GetPointData().GetArray("DisplacementNorms")
##Clamp the negative values to 0 and the positive values to one in a weight array
calculator = vtk.vtkArrayCalculator()
calculator.SetInput(sampler.GetOutput())
calculator.AddScalarArrayName("DisplacementNorms")
calculator.SetFunction("if( DisplacementNorms > 0 , iHat, jHat)")
calculator.SetResultArrayName("Weights")
calculator.SetResultArrayType(vtk.VTK_FLOAT)
calculator.Update()
# Create the transform
thinPlateSplineTransform = vtk.vtkThinPlateSplineTransform()
thinPlateSplineTransform.SetBasisToR()
thinPlateSplineTransform.SetSourceLandmarks(self.SourcePoints)
thinPlateSplineTransform.SetTargetLandmarks(self.TargetPoints)
transform = vtk.vtkTransform()
transform.Identity()
transform2 = vtk.vtkTransform()
transform2.Identity()
# Apply weighted transform
transformFilter = vtk.vtkWeightedTransformFilter()
transformFilter.SetInput(calculator.GetOutput())
transformFilter.SetNumberOfTransforms(3)
transformFilter.SetWeightArray("Weights")
transformFilter.SetTransform(thinPlateSplineTransform, 0)
transformFilter.SetTransform(transform, 1)
transformFilter.SetTransform(transform2, 2)
transformFilter.Update()
normalsFilter = vtk.vtkPolyDataNormals()
normalsFilter.SetInput(transformFilter.GetOutput())
normalsFilter.Update()
# FIXME: the normal filter apparently introduced some holes in some meshes (wtf?). This filter cleans the mesh
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInput(normalsFilter.GetOutput())
cleanFilter.Update()
self.DeformedSurface = cleanFilter.GetOutput()
def vtk_ellipsoid_topomesh(ellipsoid_radius=50.0, ellipsoid_scales=[1,1,1], ellipsoid_axes=np.diag(np.ones(3)), ellipsoid_center=np.zeros(3)):
"""
"""
import vtk
from openalea.cellcomplex.property_topomesh.utils.image_tools import vtk_polydata_to_triangular_mesh
ico = vtk.vtkPlatonicSolidSource()
ico.SetSolidTypeToIcosahedron()
ico.Update()
subdivide = vtk.vtkLoopSubdivisionFilter()
subdivide.SetNumberOfSubdivisions(3)
subdivide.SetInputConnection(ico.GetOutputPort())
subdivide.Update()
scale_transform = vtk.vtkTransform()
scale_factor = ellipsoid_radius/(np.sqrt(2)/2.)
scale_transform.Scale(scale_factor,scale_factor,scale_factor)
ellipsoid_sphere = vtk.vtkTransformPolyDataFilter()
ellipsoid_sphere.SetInput(subdivide.GetOutput())
ellipsoid_sphere.SetTransform(scale_transform)
ellipsoid_sphere.Update()
ellipsoid_transform = vtk.vtkTransform()
axes_transform = vtk.vtkLandmarkTransform()
source_points = vtk.vtkPoints()
source_points.InsertNextPoint([1,0,0])
source_points.InsertNextPoint([0,1,0])
source_points.InsertNextPoint([0,0,1])
target_points = vtk.vtkPoints()
target_points.InsertNextPoint(ellipsoid_axes[0])
target_points.InsertNextPoint(ellipsoid_axes[1])
target_points.InsertNextPoint(ellipsoid_axes[2])
axes_transform.SetSourceLandmarks(source_points)
axes_transform.SetTargetLandmarks(target_points)
axes_transform.SetModeToRigidBody()
axes_transform.Update()
ellipsoid_transform.SetMatrix(axes_transform.GetMatrix())
ellipsoid_transform.Scale(ellipsoid_scales[0],ellipsoid_scales[1],ellipsoid_scales[2])
center_transform = vtk.vtkTransform()
center_transform.Translate(ellipsoid_center[0],ellipsoid_center[1],ellipsoid_center[2])
center_transform.Concatenate(ellipsoid_transform)
ellipsoid_ellipsoid = vtk.vtkTransformPolyDataFilter()
ellipsoid_ellipsoid.SetInput(ellipsoid_sphere.GetOutput())
ellipsoid_ellipsoid.SetTransform(center_transform)
ellipsoid_ellipsoid.Update()
ellipsoid_mesh = vtk_polydata_to_triangular_mesh(ellipsoid_ellipsoid.GetOutput())
topomesh = triangle_topomesh(ellipsoid_mesh.triangles.values(),ellipsoid_mesh.points)
return topomesh
def get_cylinder(upper, height, radius,
direction,
resolution=10):
src = vtk.vtkCylinderSource()
src.SetCenter((0, height/2, 0))
src.SetHeight(height + radius/2.0)
src.SetRadius(radius)
src.SetResolution(resolution)
rot1 = vtk.vtkTransform()
fi = nm.arccos(direction[1])
rot1.RotateWXYZ(-nm.rad2deg(fi), 0.0, 0.0, 1.0)
u = nm.abs(nm.sin(fi))
rot2 = vtk.vtkTransform()
if u > 1.0e-6:
# sometimes d[0]/u little bit is over 1
d0_over_u = direction[0] / u
if d0_over_u > 1:
psi = 0
elif d0_over_u < -1:
psi = 2 * nm.pi
else:
psi = nm.arccos(direction[0] / u)
logger.debug('d0 '+str(direction[0])+' u '+str(u)+' psi '+str(psi))
if direction[2] < 0:
psi = 2 * nm.pi - psi
rot2.RotateWXYZ(-nm.rad2deg(psi), 0.0, 1.0, 0.0)
tl = vtk.vtkTransform()
tl.Translate(upper)
tr1a = vtk.vtkTransformFilter()
tr1a.SetInput(src.GetOutput())
tr1a.SetTransform(rot1)
tr1b = vtk.vtkTransformFilter()
tr1b.SetInput(tr1a.GetOutput())
tr1b.SetTransform(rot2)
tr2 = vtk.vtkTransformFilter()
tr2.SetInput(tr1b.GetOutput())
tr2.SetTransform(tl)
tr2.Update()
return tr2.GetOutput()
def test_Segmentation(self):
""" Test the GetRASBounds & GetBounds method on a segmentation.
"""
#self.delayDisplay("Starting test_Segmentation")
cubeSource = vtk.vtkCubeSource()
cubeSource.SetXLength(500)
cubeSource.SetYLength(200)
cubeSource.SetZLength(300)
cubeSource.SetCenter(10, -85, 0.7)
rotation = vtk.vtkTransform()
rotation.RotateX(15.0)
rotation.RotateZ(78)
applyTransform = vtk.vtkTransformPolyDataFilter()
applyTransform.SetTransform(rotation)
applyTransform.SetInputConnection(cubeSource.GetOutputPort())
applyTransform.Update()
modelNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLModelNode())
modelNode.SetPolyDataConnection(applyTransform.GetOutputPort())
segmentationNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLSegmentationNode())
segmentationLogic = slicer.modules.segmentations.logic()
segmentationLogic.ImportModelToSegmentationNode(modelNode, segmentationNode)
# Testing
bounds = range(6)
segmentationNode.GetRASBounds(bounds)
untransformedBounds = [-65.0710220336914, 235.9289779663086, -304.413391113281, 288.586608886719, -216.427032470703, 213.572967529297]
self.assertListAlmostEquals(bounds, untransformedBounds)
segmentationNode.GetBounds(bounds)
self.assertListAlmostEquals(bounds, untransformedBounds)
transform = vtk.vtkTransform()
transform.Translate([-5.0, +42.0, -0.1])
transform.RotateWXYZ(41, 0.7, 0.6, 75)
transform.Scale(2, 3, 10)
transformNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLTransformNode())
transformNode.ApplyTransform(transform)
segmentationNode.SetAndObserveTransformNodeID(transformNode.GetID())
transformedBounds = [-200.70776329131795, 479.54290966330126, -723.6172978253361, 996.0765602877555, -2171.2883672792996, 2141.1537548033725]
segmentationNode.GetRASBounds(bounds)
self.assertListAlmostEquals(bounds, transformedBounds)
segmentationNode.GetBounds(bounds)
self.assertListAlmostEquals(bounds, untransformedBounds)
def test_Segmentation(self):
""" Test the GetRASBounds & GetBounds method on a segmentation.
"""
#self.delayDisplay("Starting test_Segmentation")
cubeSource = vtk.vtkCubeSource()
cubeSource.SetXLength(500)
cubeSource.SetYLength(200)
cubeSource.SetZLength(300)
cubeSource.SetCenter(10, -85, 0.7)
rotation = vtk.vtkTransform()
rotation.RotateX(15.0)
rotation.RotateZ(78)
applyTransform = vtk.vtkTransformPolyDataFilter()
applyTransform.SetTransform(rotation)
applyTransform.SetInputConnection(cubeSource.GetOutputPort())
applyTransform.Update()
modelNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLModelNode())
modelNode.SetPolyDataConnection(applyTransform.GetOutputPort())
segmentationNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLSegmentationNode())
segmentationLogic = slicer.modules.segmentations.logic()
segmentationLogic.ImportModelToSegmentationNode(modelNode, segmentationNode)
# Testing
bounds = range(6)
segmentationNode.GetRASBounds(bounds)
untransformedBounds = [-65.4164152220677, 237.23434621664234, -305.4495706784099, 289.7072339384947, -217.46321203583187, 213.68731403607347]
self.assertListAlmostEquals(bounds, untransformedBounds)
segmentationNode.GetBounds(bounds)
self.assertListAlmostEquals(bounds, untransformedBounds)
transform = vtk.vtkTransform()
transform.Translate([-5.0, +42.0, -0.1])
transform.RotateWXYZ(41, 0.7, 0.6, 75)
transform.Scale(2, 3, 10)
transformNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLTransformNode())
transformNode.ApplyTransform(transform)
segmentationNode.SetAndObserveTransformNodeID(transformNode.GetID())
transformedBounds = [-690.2701685073098, 970.3186946284741, -744.3124542486084, 1018.260811721817, -2183.4639807718822, 2144.107746300856]
segmentationNode.GetRASBounds(bounds)
self.assertListAlmostEquals(bounds, transformedBounds)
segmentationNode.GetBounds(bounds)
self.assertListAlmostEquals(bounds, untransformedBounds)
def drawFrameInCamera(self, t, frameName='new frame',visible=True):
imageView = self.cameraView.views[self.imageViewName]
v = imageView.view
q = self.cameraView.imageManager.queue
localToCameraT = vtk.vtkTransform()
q.getTransform('local', self.imageViewName, localToCameraT)
res = vis.showFrame( vtk.vtkTransform() , 'temp', view=v, visible=True, scale = 0.2)
om.removeFromObjectModel(res)
pd = res.polyData
pd = filterUtils.transformPolyData(pd, t)
pd = filterUtils.transformPolyData(pd, localToCameraT)
q.projectPoints(self.imageViewName, pd )
vis.showPolyData(pd, ('overlay ' + frameName), view=v, colorByName='Axes',parent='camera overlay',visible=visible)
def colladaGeometryToPolyData(geometry, transform):
polyDataList = []
for primitives in geometry.primitives:
if type(primitives) != collada.triangleset.TriangleSet:
print 'warning, unhandled primitive type:', type(primitives)
continue
polyData = colladaTriangleSetToPolyData(primitives)
if not polyData:
continue
addTextureMetaData(polyData, primitives.material)
t = vtk.vtkTransform()
t.PostMultiply()
t.Scale(0.0254, 0.0254, 0.0254)
t.RotateX(-90)
polyData = transformPolyData(polyData, t)
polyData = transformPolyData(polyData, transform)
polyDataList.append(polyData)
return polyDataList
def __init__(self, renderers, radius = 2.0, height = 8.0, rotationXYZ = [0, 0, 0], offsetXYZ = [0, 0, 0]):
'''
Initialize the cylinder.
'''
# Call the parent constructor
super(Cylinder,self).__init__(renderers)
cylinderSource = vtk.vtkCylinderSource()
cylinderSource.SetCenter(0.0, 0.0, 0.0)
cylinderSource.SetRadius(radius)
cylinderSource.SetHeight(height)
# Make it a little more defined
cylinderSource.SetResolution(24)
# Transform scale it to the right size
trans = vtk.vtkTransform()
trans.Scale(1, 1, 1)
trans.Translate(offsetXYZ[0], offsetXYZ[1], offsetXYZ[2])
trans.RotateZ(rotationXYZ[2])
trans.RotateX(rotationXYZ[0])
trans.RotateY(rotationXYZ[1])
transF = vtk.vtkTransformPolyDataFilter()
transF.SetInputConnection(cylinderSource.GetOutputPort())
transF.SetTransform(trans)
cylinderMapper = vtk.vtkPolyDataMapper()
cylinderMapper.SetInputConnection(transF.GetOutputPort())
self.vtkActor.SetMapper(cylinderMapper)
# Change it to a red sphere
self.vtkActor.GetProperty().SetColor(0.8, 0.8, 0.3)
def WriteVTSXMLVolumeFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTS XML grid file.')
if self.ApplyTransform == 0:
origin = self.Image.GetOrigin()
spacing = self.Image.GetSpacing()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy((1/spacing[0], 0, 0, - origin[0]/spacing[0],
0, 1/spacing[1], 0, - origin[1]/spacing[1],
0, 0, 1/spacing[2], - origin[2]/spacing[2],
0, 0, 0, 1)) #LPI convention with correct origin and spacing
else:
if self.RasToIjkMatrixCoefficients == None:
self.PrintError('Error: no RasToIjkMatrixCoefficients.')
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
trans = vtk.vtkTransform()
trans.SetMatrix(matrix)
trans_filt = vtk.vtkTransformFilter()
trans_filt.SetTransform(trans)
trans_filt.SetInputData(self.Image)
trans_filt.Update()
writer = vtk.vtkXMLStructuredGridWriter()
writer.SetInputConnection(trans_filt.GetOutputPort())
writer.SetFileName(self.OutputFileName)
writer.Write()
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 rotateMesh(mesh, axis=1, angle=0):
try:
print("Rotating surface: axis=", axis, "angle=", angle)
matrix = vtk.vtkTransform()
if axis == 0:
matrix.RotateX(angle)
if axis == 1:
matrix.RotateY(angle)
if axis == 2:
matrix.RotateZ(angle)
tfilter = vtk.vtkTransformPolyDataFilter()
tfilter.SetTransform(matrix)
if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
tfilter.SetInputData(mesh)
else:
tfilter.SetInput(mesh)
tfilter.Update()
mesh2 = tfilter.GetOutput()
return mesh2
except:
print("Surface rotating failed")
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(
exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def Execute(self):
if (self.Mesh == None):
self.PrintError('Error: no Mesh.')
if not self.Matrix4x4:
self.Matrix4x4 = vtk.vtkMatrix4x4()
if self.MatrixCoefficients != []:
self.PrintLog('Setting up transform matrix using specified coefficients')
self.Matrix4x4.DeepCopy(self.MatrixCoefficients)
elif self.Translation != [0.0,0.0,0.0] or self.Rotation != [0.0,0.0,0.0] or self.Scaling != [1.0,1.0,1.0]:
self.PrintLog('Setting up transform matrix using specified translation, rotation and/or scaling')
transform = vtk.vtkTransform()
transform.RotateX(self.Rotation[0])
transform.RotateY(self.Rotation[1])
transform.RotateZ(self.Rotation[2])
transform.Translate(self.Translation[0], self.Translation[1], self.Translation[2])
transform.Scale(self.Scaling[0], self.Scaling[1], self.Scaling[2])
self.Matrix4x4.DeepCopy(transform.GetMatrix())
if self.InvertMatrix:
self.Matrix4x4.Invert()
transform = vtk.vtkMatrixToLinearTransform()
transform.SetInput(self.Matrix4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputData(self.Mesh)
transformFilter.SetTransform(transform)
transformFilter.Update()
self.Mesh = transformFilter.GetOutput()
def select_point_cloud(self):
if not self.scene.get_active_point_cloud(): return
self.unselect_point_cloud()
transform = vtk.vtkTransform()
transform.SetMatrix(self.actor.GetMatrix())
transform_filter = vtk.vtkTransformPolyDataFilter()
transform_filter.SetInputConnection(self.src.GetOutputPort())
transform_filter.SetTransform(transform)
enclosed_pts = vtk.vtkSelectEnclosedPoints()
if USING_VTK6:
enclosed_pts.SetInputData(self.scene.get_active_point_cloud().polydata)
enclosed_pts.SetSurfaceConnection(transform_filter.GetOutputPort())
else:
enclosed_pts.SetInput(self.scene.get_active_point_cloud().polydata)
enclosed_pts.SetSurface(transform_filter.GetOutput())
enclosed_pts.Update()
inside_arr = enclosed_pts.GetOutput().GetPointData().\
GetArray('SelectedPoints')
self.selected_pts = []
for i in range(inside_arr.GetNumberOfTuples()):
if inside_arr.GetComponent(i, 0):
self.scene.get_active_point_cloud().colors.\
SetTuple3(i, *name_to_rgb('blue'))
self.selected_pts.append(i)
self.scene.get_active_point_cloud().selected_pts[i] += 1
self.scene.get_active_point_cloud().colors.Modified()
self.frame.ren_win.Render()
def SetInlet(self, inlet):
"""Create a vtkTransform which will rotate the coordinates such that
inlet.Normal is oriented in the z-direction and origin is inlet.Centre
"""
n = inlet.Normal
n = np.array([n.x, n.y, n.z])
minInd = n.argsort()[0]
axis = np.zeros(3)
axis[minInd] = 1
transmat = np.eye(4)
transmat[0, 0:3] = np.cross(n, axis)
transmat[0, 0:3] /= np.sqrt(np.sum(transmat[0, 0:3]**2))
transmat[1, 0:3] = np.cross(n, transmat[0, 0:3])
transmat[2, 0:3] = n
trans = vtkTransform()
trans.Scale(1., 1., 0.)
trans.Concatenate(transmat.flatten())
r = inlet.Centre
trans.Translate(r.x, r.y, r.z)
self.trans = trans
self.transformer.SetTransform(self.trans)
return
def __init__(self, renderers, name):
'''
Initialize the bot model.
'''
# Call the parent constructor
super(RoverBot,self).__init__(renderers)
filename = "../scene/media/rover.stl"
self.__name = name
reader = vtk.vtkSTLReader()
reader.SetFileName(filename)
# Do the internal transforms to make it look along unit-z, do it with a quick transform
trans = vtk.vtkTransform()
trans.Scale(0.05, 0.05, 0.05)
trans.RotateX(-90)
transF = vtk.vtkTransformPolyDataFilter()
transF.SetInputConnection(reader.GetOutputPort())
transF.SetTransform(trans)
self.__mapper = vtk.vtkPolyDataMapper()
#if vtk.VTK_MAJOR_VERSION <= 5:
# self.__mapper.SetInput(reader.GetOutput())
#else:
self.__mapper.SetInputConnection(transF.GetOutputPort())
self.vtkActor.SetMapper(self.__mapper)
# Set up all the children for this model
self.__setupChildren(renderers)
# Set it to [0,0,0] so that it updates all the children
self.SetSceneObjectPosition([0, 0, 0])
def test_3D_interactionDefaults(self):
""" Test that the interaction widget exists in the 3D view.
"""
logic = SlicerTransformInteractionTest1Logic()
#self.delayDisplay("Starting test_3D_interactionDefaults")
logic = SlicerTransformInteractionTest1Logic()
tNode, tdNode = logic.addTransform()
self.assertFalse(tdNode.GetEditorVisibility())
self.assertFalse(tdNode.GetEditorSliceIntersectionVisibility())
slicer.app.layoutManager().layout = slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView
manager = logic.getModel3DDisplayableManager()
self.assertIsNotNone(manager)
# Check when nothing is on
widget = manager.GetWidget(tdNode)
self.assertFalse(widget.GetEnabled())
# Check when interactive is on
tdNode.SetEditorVisibility(True)
self.assertTrue(widget.GetEnabled())
# Check default widget tranform values
representation = widget.GetRepresentation()
defaultTransform = vtk.vtkTransform()
representation.GetTransform(defaultTransform)
expectedDefaultTransform = [
[100.0, 0.0, 0.0, 0.0],
[0.0, 100.0, 0.0, 0.0],
[0.0, 0.0, 100.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
]
self.assertTransform(defaultTransform, expectedDefaultTransform)
def RotateBond(self, angle, mode="up"):
trans = vtk.vtkTransform()
trans.PostMultiply()
if mode == "down":
pos = self.bond_atoms[1].pos.copy()
v = self.bond_atoms[0].pos - self.bond_atoms[1].pos
self.Translate(-1 * pos)
trans.RotateWXYZ(angle, v[0], v[1], v[2])
for atom in self:
atom.ApplyTransform(trans)
if atom is self.bond_atoms[0]:
atom.ApplyTransform(trans)
break
elif mode == "up":
pos = self.bond_atoms[0].pos.copy()
v = self.bond_atoms[1].pos - self.bond_atoms[0].pos
self.Translate(-1 * pos)
trans.RotateWXYZ(angle, v[0], v[1], v[2])
aux_flag = False
for atom in self:
if aux_flag:
atom.ApplyTransform(trans)
elif atom is self.bond_atoms[0]:
aux_flag = True
self.Translate(pos)
def RandomizeLocation(self, vec):
"""Randomiztion of location respecting to the vec.
"""
trans = vtk.vtkTransform()
random_vector = [vec[0] * rand.random(), vec[1] * rand.random(), vec[2] * rand.random()]
trans.Translate(random_vector)
self.ApplyTransform(trans)
def create_glyphs (self, poly):
if self.glyph_type == 'sphere':
glyph = vtk.vtkSphereSource()
glyph.SetRadius(1)
glyph.SetPhiResolution(8)
glyph.SetThetaResolution(8)
elif self.glyph_type == 'cylinder':
glyph = vtk.vtkCylinderSource()
glyph.SetHeight(self.height)
glyph.SetRadius(self.radius)
glyph.SetCenter(0,0,0)
glyph.SetResolution(10)
glyph.CappingOn()
tt = vtk.vtkTransform()
tt.RotateZ(90)
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInput(glyph.GetOutput())
tf.SetTransform(tt)
tf.Update()
glypher = vtk.vtkGlyph3D()
glypher.SetInput(poly)
glypher.SetSource(tf.GetOutput())
glypher.SetVectorModeToUseNormal()
glypher.SetScaleModeToScaleByScalar()
glypher.SetScaleFactor(self.glyph_scale_factor)
glypher.Update()
return glypher
def GetLineFromWidget(self, obj, event):
if self.Type == "freehand":
path = vtk.vtkPolyData()
obj.GetPath(path)
elif self.Type == "contour":
path = self.ImageTracerWidget.GetRepresentation().GetContourRepresentationAsPolyData()
spacing = self.Image.GetSpacing()
translation = [0.0, 0.0, 0.0]
translation[self.Axis] = self.SliceVOI[self.Axis * 2] * spacing[self.Axis]
transform = vtk.vtkTransform()
transform.Translate(translation)
pathTransform = vtk.vtkTransformPolyDataFilter()
pathTransform.SetInput(path)
pathTransform.SetTransform(transform)
pathTransform.Update()
self.Line = pathTransform.GetOutput()
if self.Line.GetSource():
self.Line.GetSource().UnRegisterAllOutputs()
def __init__(self,center=(0,-2,0) , radius=0.5, height=2, color=(0,1,1),
rotXYZ=(0,0,0), resolution=50 ):
""" cylinder """
self.src = vtk.vtkCylinderSource()
self.src.SetCenter(0,0,0)
self.src.SetHeight(height)
self.src.SetRadius(radius)
self.src.SetResolution(resolution)
# SetResolution
# SetCapping(int)
# CappingOn() CappingOff()
# this transform rotates the cylinder so it is vertical
# and then translates the lower tip to the center point
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2]+height/2)
transform.RotateX(rotXYZ[0])
transformFilter=vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(self.src.GetOutputPort())
transformFilter.Update()
self.mapper = vtk.vtkPolyDataMapper()
#self.mapper.SetInput(self.src.GetOutput())
self.mapper.SetInput( transformFilter.GetOutput() )
self.SetMapper(self.mapper)
self.SetColor(color)
def CreateTorus(point1, point2, axe): """ Creates a torus that has point1 as center point2 defines a point on the torus. """ direction = map(lambda x, y: x - y, point2, point1) length = math.sqrt(sum(map(lambda x: x ** 2, direction))) torus = vtkParametricTorus() torus.SetRingRadius(length / 1.5) torus.SetCrossSectionRadius(length / 30.0) torusSource = vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusSource.Update() transform = vtkTransform() if axe == 0: transform.RotateY(90) elif axe == 1: transform.RotateX(90) transformFilter = vtkTransformFilter() transformFilter.SetInputConnection(torusSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() torusMapper = vtkPolyDataMapper() torusMapper.SetInputConnection(transformFilter.GetOutputPort()) torusActor = vtkActor() torusActor.SetMapper(torusMapper) return torusActor, transformFilter.GetOutput()
def __init__(self, center=(-2,0,0), radius = 1, angle=45, height=0.4, color=(1,1,0) , resolution=60):
""" cone"""
self.src = vtk.vtkConeSource()
self.src.SetResolution(resolution)
self.src.SetRadius( radius )
#self.src.SetAngle( angle )
self.src.SetHeight( height )
#self.src.SetCenter(center)
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2] - self.src.GetHeight()/2)
#transform.RotateX(rotXYZ[0])
transform.RotateY( -90 )
#transform.RotateZ(rotXYZ[2])
transformFilter=vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(self.src.GetOutputPort())
transformFilter.Update()
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInput(transformFilter.GetOutput())
#self.mapper = vtk.vtkPolyDataMapper()
#self.mapper.SetInput(self.src.GetOutput())
self.SetMapper(self.mapper)
self.SetColor(color)
def transform_back(self,pt,pd): #The reconstructed surface is transformed back to where the #original points are. (Hopefully) it is only a similarity #transformation. #1. Get bounding box of pt, get its minimum corner (left, bottom, least-z), at c0, pt_bounds #2. Get bounding box of surface pd, get its minimum corner (left, bottom, least-z), at c1, pd_bounds #3. compute scale as: # scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]); #4. transform the surface by T := T(pt_bounds[0], [2], [4]).S(scale).T(-pd_bounds[0], -[2], -[4]) pt_bounds=pt.GetBounds() pd_bounds=pd.GetBounds() scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]); transp = vtk.vtkTransform() transp.Translate(pt_bounds[0], pt_bounds[2], pt_bounds[4]); transp.Scale(scale, scale, scale); transp.Translate(- pd_bounds[0], - pd_bounds[2], - pd_bounds[4]); tpd = vtk.vtkTransformPolyDataFilter(); tpd.SetInput(pd); tpd.SetTransform(transp); tpd.Update(); return tpd.GetOutput();
def __init__(self, color=(1,1,1), center=(0,0,0), text="hello", scale=1, camera=[]):
""" create text """
self.src = vtk.vtkVectorText()
self.SetText(text)
#self.SetCamera(camera)
transform = vtk.vtkTransform()
transform.Translate(center[0], center[1], center[2])
transform.Scale(scale, scale, scale)
#transform.RotateY(90)
#transform2 = vtk.vtkTransform()
#transform.Concatenate(transform2)
#transformFilter=vtk.vtkTransformPolyDataFilter()
#transformFilter.SetTransform(transform)
#transformFilter.SetInputConnection(self.src.GetOutputPort())
#transformFilter.Update()
#follower = vtk.vtkFollower()
#follower.SetMapper
self.SetUserTransform(transform)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.src.GetOutputPort())
self.SetMapper(self.mapper)
self.SetColor(color)
def GetTransform(rotationAngle, rotationVector):
transform = vtk.vtkTransform()
transform.RotateWXYZ(rotationAngle, rotationVector[0], rotationVector[1],
rotationVector[2])
return transform
def myCallback(widget, event_string):
t = vtk.vtkTransform()
boxWidget.GetTransform(t)
boxWidget.GetProp3D().SetUserTransform(t)
faceColors.InsertComponent(2,1,255) faceColors.InsertComponent(2,2,0) faceColors.InsertComponent(3,0,0) faceColors.InsertComponent(3,1,0) faceColors.InsertComponent(3,2,255) faceColors.InsertComponent(4,0,255) faceColors.InsertComponent(4,1,0) faceColors.InsertComponent(4,2,255) faceColors.InsertComponent(5,0,0) faceColors.InsertComponent(5,1,255) faceColors.InsertComponent(5,2,255) cube = vtk.vtkPolyData() cube.SetPoints(pts) cube.SetPolys(faces) cube.GetCellData().SetScalars(faceColors) t1 = vtk.vtkTransform() t1.Translate(1,2,3) t1.RotateX(15) t1.Scale(4,2,1) tpdf1 = vtk.vtkTransformPolyDataFilter() tpdf1.SetInputData(cube) tpdf1.SetTransform(t1) cube1Mapper = vtk.vtkPolyDataMapper() cube1Mapper.SetInputConnection(tpdf1.GetOutputPort()) cube1 = vtk.vtkActor() cube1.SetMapper(cube1Mapper) t2 = vtk.vtkTransform() t2.Translate(5,10,15) t2.RotateX(22.5) t2.RotateY(15) t2.RotateZ(85)
f22.SetInputConnection(ap.GetOutputPort()) f22.SetTransform(t2.GetInverse()) m22 = vtk.vtkDataSetMapper() m22.SetInputConnection(f22.GetOutputPort()) a22 = vtk.vtkActor() a22.SetMapper(m22) a22.GetProperty().SetColor(0.9, 0.9, 0) a22.GetProperty().SetRepresentationToWireframe() ren22 = vtk.vtkRenderer() ren22.SetViewport(0.25, 0.0, 0.50, 0.5) ren22.ResetCamera(-0.5, 0.5, -0.5, 0.5, -1, 1) ren22.AddActor(a22) renWin.AddRenderer(ren22) #-------------------------- # linear concatenation - should end up with identity here t3 = vtk.vtkTransform() t3.Concatenate(t1) t3.Concatenate(t1.GetInverse()) f31 = vtk.vtkTransformPolyDataFilter() f31.SetInputConnection(ap.GetOutputPort()) f31.SetTransform(t3) m31 = vtk.vtkDataSetMapper() m31.SetInputConnection(f31.GetOutputPort()) a31 = vtk.vtkActor() a31.SetMapper(m31) a31.GetProperty().SetColor(1, 0, 0) a31.GetProperty().SetRepresentationToWireframe() ren31 = vtk.vtkRenderer() ren31.SetViewport(0.50, 0.5, 0.75, 1.0) ren31.ResetCamera(-0.5, 0.5, -0.5, 0.5, -1, 1) ren31.AddActor(a31)
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# this script tests vtkImageReslice with different interpolation modes,
# with the wrap-pad feature turned on and with a rotation
# Image pipeline
reader = vtk.vtkImageReader()
reader.ReleaseDataFlagOff()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0, 63, 0, 63, 1, 93)
reader.SetDataSpacing(3.2, 3.2, 1.5)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
transform = vtk.vtkTransform()
# rotate about the center of the image
transform.Translate(+100.8, +100.8, +69.0)
transform.RotateWXYZ(100, 0.1, 0.1, 1)
transform.Translate(-100.8, -100.8, -69.0)
reslice1 = vtk.vtkImageReslice()
reslice1.SetInputConnection(reader.GetOutputPort())
reslice1.MirrorOn()
reslice1.SetResliceTransform(transform)
reslice1.SetInterpolationModeToCubic()
reslice1.SetOutputSpacing(2.0, 2.0, 1.5)
reslice1.SetOutputOrigin(-32, -32, 40)
reslice1.SetOutputExtent(0, 127, 0, 127, 0, 0)
reslice2 = vtk.vtkImageReslice()
reslice2.SetInputConnection(reader.GetOutputPort())
reslice2.MirrorOn()
def createMeshFromSegmentationCleaver(self, inputSegmentation, outputMeshNode, additionalParameters="--scale 0.2 --multiplier 2 --grading 5"):
self.abortRequested = False
tempDir = self.createTempDirectory()
self.addLog('Mesh generation using Cleaver is started in working directory: '+tempDir)
inputParamsCleaver = []
# Write inputs
qt.QDir().mkpath(tempDir)
labelmapVolumeNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLLabelMapVolumeNode')
slicer.modules.segmentations.logic().ExportAllSegmentsToLabelmapNode(inputSegmentation, labelmapVolumeNode)
inputLabelmapVolumeFilePath = os.path.join(tempDir, "inputLabelmap.nrrd")
slicer.util.saveNode(labelmapVolumeNode, inputLabelmapVolumeFilePath, {"useCompression": False})
inputParamsCleaver.extend(["--input_files", inputLabelmapVolumeFilePath])
inputParamsCleaver.append("--segmentation")
# Keep IJK to RAS matrix, we'll need it later
unscaledIjkToRasMatrix = vtk.vtkMatrix4x4()
labelmapVolumeNode.GetIJKToRASDirectionMatrix(unscaledIjkToRasMatrix)
origin = labelmapVolumeNode.GetOrigin()
for i in range(3):
unscaledIjkToRasMatrix.SetElement(i,3, origin[i])
# Keep color node, we'll need it later
colorTableNode = labelmapVolumeNode.GetDisplayNode().GetColorNode()
# Background color is transparent by default which is not ideal for 3D display
colorTableNode.SetColor(0,0.6,0.6,0.6,1.0)
slicer.mrmlScene.RemoveNode(labelmapVolumeNode)
slicer.mrmlScene.RemoveNode(colorTableNode)
# Set up output format
inputParamsCleaver.extend(["--output_path", tempDir+"/"])
inputParamsCleaver.extend(["--output_format", "vtkUSG"]) # VTK unstructed grid
inputParamsCleaver.append("--fix_tet_windup") # prevent inside-out tets
inputParamsCleaver.append("--strip_exterior") # remove temporary elements that are added to make the volume cubic
inputParamsCleaver.append("--verbose")
# Quality
inputParamsCleaver.extend(slicer.util.toVTKString(additionalParameters).split(' '))
# Run Cleaver
ep = self.startMesher(inputParamsCleaver, self.getCleaverPath())
self.logProcessOutput(ep, self.cleaverFilename)
# Read results
if not self.abortRequested:
outputVolumetricMeshPath = os.path.join(tempDir, "output.vtk")
outputReader = vtk.vtkUnstructuredGridReader()
outputReader.SetFileName(outputVolumetricMeshPath)
outputReader.ReadAllScalarsOn()
outputReader.ReadAllVectorsOn()
outputReader.ReadAllNormalsOn()
outputReader.ReadAllTensorsOn()
outputReader.ReadAllColorScalarsOn()
outputReader.ReadAllTCoordsOn()
outputReader.ReadAllFieldsOn()
outputReader.Update()
# Cleaver returns the mesh in voxel coordinates, need to transform to RAS space
transformer = vtk.vtkTransformFilter()
transformer.SetInputData(outputReader.GetOutput())
ijkToRasTransform = vtk.vtkTransform()
ijkToRasTransform.SetMatrix(unscaledIjkToRasMatrix)
transformer.SetTransform(ijkToRasTransform)
outputMeshNode.SetUnstructuredGridConnection(transformer.GetOutputPort())
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
if not outputMeshDisplayNode:
# Initial setup of display node
outputMeshNode.CreateDefaultDisplayNodes()
outputMeshDisplayNode = outputMeshNode.GetDisplayNode()
outputMeshDisplayNode.SetEdgeVisibility(True)
outputMeshDisplayNode.SetClipping(True)
colorTableNode = slicer.mrmlScene.AddNode(colorTableNode)
outputMeshDisplayNode.SetAndObserveColorNodeID(colorTableNode.GetID())
outputMeshDisplayNode.ScalarVisibilityOn()
outputMeshDisplayNode.SetActiveScalarName('labels')
outputMeshDisplayNode.SetActiveAttributeLocation(vtk.vtkAssignAttribute.CELL_DATA);
outputMeshDisplayNode.SetSliceIntersectionVisibility(True)
outputMeshDisplayNode.SetSliceIntersectionOpacity(0.5)
else:
currentColorNode = outputMeshDisplayNode.GetColorNode()
if currentColorNode.GetType() == currentColorNode.User and currentColorNode.IsA("vtkMRMLColorTableNode"):
# current color table node can be overwritten
currentColorNode.Copy(colorTableNode)
else:
colorTableNode = slicer.mrmlScene.AddNode(colorTableNode)
outputMeshDisplayNode.SetAndObserveColorNodeID(colorTableNode.GetID())
# Clean up
if self.deleteTemporaryFiles:
import shutil
shutil.rmtree(tempDir)
self.addLog("Model generation is completed")
def obs_to_world(self, pnt):
if not self.hasData: return
spacing = self.imageData.GetSpacing()
transform = vtk.vtkTransform()
transform.Scale(spacing)
return transform.TransformPoint(pnt)
def plot(self, color='w', show_edges=True, **kwargs):
"""Plot the full rotor geometry.
Parameters
----------
color : string or 3 item list, optional, defaults to white
Either a string, rgb list, or hex color string. For
example:
``color='white'``
``color='w'``
``color=[1, 1, 1]``
``color='#FFFFFF'``
Color will be overridden when scalars are input.
show_edges : bool, optional
Shows the edges of a mesh. Does not apply to a wireframe
representation.
style : string, optional
Visualization style of the vtk mesh. One for the
following:
``style='surface'``
``style='wireframe'``
``style='points'``
Defaults to 'surface'
off_screen : bool
Plots off screen when True. Helpful for saving
screenshots without a window popping up.
full_screen : bool, optional
Opens window in full screen. When enabled, ignores
window_size. Default False.
screenshot : str or bool, optional
Saves screenshot to file when enabled. See:
help(pyvista.Plotter.screenshot). Default disabled.
When True, takes screenshot and returns numpy array of
image.
window_size : list, optional
Window size in pixels. Defaults to [1024, 768]
show_bounds : bool, optional
Shows mesh bounds when True. Default False. Alias
``show_grid`` also accepted.
show_axes : bool, optional
Shows a vtk axes widget. Enabled by default.
Returns
-------
cpos : list
List of camera position, focal point, and view up.
"""
cs_cord = self.resultheader['csCord']
if cs_cord > 1:
matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix.Invert()
else:
matrix = vtk.vtkMatrix4x4()
i_matrix = vtk.vtkMatrix4x4()
off_screen = kwargs.pop('off_screen', None)
window_size = kwargs.pop('window_size', None)
plotter = pv.Plotter(off_screen, window_size)
rang = 360.0 / self.n_sector
for i in range(self.n_sector):
actor = plotter.add_mesh(self.grid.copy(False),
color=color,
show_edges=show_edges, **kwargs)
# transform to standard position, rotate about Z axis,
# transform back
transform = vtk.vtkTransform()
transform.RotateZ(rang*i)
transform.Update()
rot_matrix = transform.GetMatrix()
if cs_cord > 1:
temp_matrix = vtk.vtkMatrix4x4()
rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix)
rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix)
transform.SetMatrix(rot_matrix)
actor.SetUserTransform(transform)
cpos = kwargs.pop('cpos', None)
if cpos is None:
cpos = plotter.get_default_cam_pos()
plotter.camera_position = cpos
plotter.camera_set = False
else:
plotter.camera_position = cpos
return plotter.plot()
def TestSection_03_qMRMLSegmentationGeometryWidget(self):
logging.info('Test section 2: qMRMLSegmentationGeometryWidget')
binaryLabelmapReprName = slicer.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName(
)
closedSurfaceReprName = slicer.vtkSegmentationConverter.GetClosedSurfaceRepresentationName(
)
# Use MRHead and Tinypatient for testing
import SampleData
mrVolumeNode = SampleData.downloadSample("MRHead")
[tinyVolumeNode,
tinySegmentationNode] = SampleData.downloadSamples('TinyPatient')
# Convert MRHead to oriented image data
import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic
mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode(
mrVolumeNode)
mrOrientedImageData.UnRegister(None)
# Create segmentation node with binary labelmap master and one segment with MRHead geometry
segmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode')
segmentationNode.GetSegmentation().SetMasterRepresentationName(
binaryLabelmapReprName)
geometryStr = slicer.vtkSegmentationConverter.SerializeImageGeometry(
mrOrientedImageData)
segmentationNode.GetSegmentation().SetConversionParameter(
slicer.vtkSegmentationConverter.
GetReferenceImageGeometryParameterName(), geometryStr)
threshold = vtk.vtkImageThreshold()
threshold.SetInputData(mrOrientedImageData)
threshold.ThresholdByUpper(16.0)
threshold.SetInValue(1)
threshold.SetOutValue(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
threshold.Update()
segmentOrientedImageData = slicer.vtkOrientedImageData()
segmentOrientedImageData.DeepCopy(threshold.GetOutput())
mrImageToWorldMatrix = vtk.vtkMatrix4x4()
mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix)
segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix)
segment = slicer.vtkSegment()
segment.SetName('Brain')
segment.SetColor(0.0, 0.0, 1.0)
segment.AddRepresentation(binaryLabelmapReprName,
segmentOrientedImageData)
segmentationNode.GetSegmentation().AddSegment(segment)
# Create geometry widget
geometryWidget = slicer.qMRMLSegmentationGeometryWidget()
geometryWidget.setSegmentationNode(segmentationNode)
geometryWidget.editEnabled = True
geometryImageData = slicer.vtkOrientedImageData(
) # To contain the output later
# Volume source with no transforms
geometryWidget.setSourceNode(tinyVolumeNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Transformed volume source
translationTransformMatrix = vtk.vtkMatrix4x4()
translationTransformMatrix.SetElement(0, 3, 24.5)
translationTransformMatrix.SetElement(1, 3, 24.5)
translationTransformMatrix.SetElement(2, 3, 11.5)
translationTransformNode = slicer.vtkMRMLLinearTransformNode()
translationTransformNode.SetName('TestTranslation')
slicer.mrmlScene.AddNode(translationTransformNode)
translationTransformNode.SetMatrixTransformToParent(
translationTransformMatrix)
tinyVolumeNode.SetAndObserveTransformNodeID(
translationTransformNode.GetID())
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (273.3439, 272.7890, -112.25),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94)
# Volume source with isotropic spacing
tinyVolumeNode.SetAndObserveTransformNodeID(None)
geometryWidget.setIsotropicSpacing(True)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (23, 23, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414)
# Volume source with oversampling
geometryWidget.setIsotropicSpacing(False)
geometryWidget.setOversamplingFactor(2.0)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (24.5, 24.5, 11.5),
(261.0939, 260.5390, -129.5),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751)
slicer.util.delayDisplay('Volume source cases - OK')
# Segmentation source with binary labelmap master
geometryWidget.setOversamplingFactor(1.0)
geometryWidget.setSourceNode(tinySegmentationNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Segmentation source with closed surface master
tinySegmentationNode.GetSegmentation().SetConversionParameter(
'Smoothing factor', '0.0')
self.assertTrue(
tinySegmentationNode.GetSegmentation().CreateRepresentation(
closedSurfaceReprName))
tinySegmentationNode.GetSegmentation().SetMasterRepresentationName(
closedSurfaceReprName)
tinySegmentationNode.Modified(
) # Trigger re-calculation of geometry (only generic Modified event is observed)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData,
(1, 1, 1),
(-86.645, 133.929,
116.786), # current origin of the segmentation is kept
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5223040)
slicer.util.delayDisplay('Segmentation source cases - OK')
# Model source with no transform
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(
slicer.mrmlScene)
outputFolderId = shNode.CreateFolderItem(shNode.GetSceneItemID(),
'ModelsFolder')
success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModels(
tinySegmentationNode, outputFolderId)
self.assertTrue(success)
modelNode = slicer.util.getNode('Body_Contour')
geometryWidget.setSourceNode(modelNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData,
(1, 1, 1),
(-86.645, 133.929,
116.786), # current origin of the segmentation is kept
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5223040)
slicer.util.delayDisplay('Model source - OK')
# Transformed model source
rotationTransform = vtk.vtkTransform()
rotationTransform.RotateX(45)
rotationTransformMatrix = vtk.vtkMatrix4x4()
rotationTransform.GetMatrix(rotationTransformMatrix)
rotationTransformNode = slicer.vtkMRMLLinearTransformNode()
rotationTransformNode.SetName('TestRotation')
slicer.mrmlScene.AddNode(rotationTransformNode)
rotationTransformNode.SetMatrixTransformToParent(
rotationTransformMatrix)
modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID())
modelNode.Modified()
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (1, 1, 1), (-86.645, 177.282, -12.122),
[[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0],
[0.7071, -0.7071, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5229164)
slicer.util.delayDisplay('Transformed model source - OK')
# ROI source
roiNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLMarkupsROINode",
'SourceROI')
rasDimensions = [0.0, 0.0, 0.0]
rasCenter = [0.0, 0.0, 0.0]
slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, rasDimensions,
rasCenter)
print(f"rasDimensions={rasDimensions}, rasCenter={rasCenter}")
rasRadius = [x / 2.0 for x in rasDimensions]
roiNode.SetCenter(rasCenter)
roiNode.SetRadiusXYZ(rasRadius)
geometryWidget.setSourceNode(roiNode)
geometryWidget.geometryImageData(geometryImageData)
print(f"geometryImageData: {geometryImageData}")
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (1, 1, 1), (28.344, 27.789, -20.25),
[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5223040)
slicer.util.delayDisplay('ROI source - OK')
slicer.util.delayDisplay('Segmentation geometry widget test passed')
def plot_point_scalars(self, scalars, rnum=None, stitle='',
flip_scalars=None, screenshot=None, cpos=None,
off_screen=None, grid=None, add_text=True, **kwargs):
"""
Plot point scalars on active mesh.
Parameters
----------
scalars : np.ndarray
Node scalars to plot.
rnum : int, optional
Cumulative result number. Used for adding informative
text.
stitle : str, optional
Title of the scalar bar.
flip_scalars : bool, optional
Reverses the direction of the cmap.
screenshot : str, optional
When a filename, saves screenshot to disk.
cpos : list, optional
3x3 list describing the camera position. Obtain it by
getting the output of plot_point_scalars first.
interactive : bool, optional
Allows user to interact with the plot when True. Default
True.
grid : pyvista.PolyData or pyvista.UnstructuredGrid, optional
Uses self.grid by default. When specified, uses this grid
instead.
add_text : bool, optional
Adds information about the result when rnum is given.
kwargs : keyword arguments
Additional keyword arguments. See help(pyvista.plot)
Returns
-------
cpos : list
Camera position.
"""
if grid is None:
grid = self.mas_grid
window_size = kwargs.pop('window_size', None)
full_screen = kwargs.pop('full_screen', False)
cmap = kwargs.pop('cmap', 'jet')
# Plot off screen when not interactive
plotter = pv.Plotter(off_screen=off_screen)
if 'show_axes' in kwargs:
plotter.add_axes()
# set background
plotter.background_color = kwargs.pop('background', None)
rng = [np.nanmin(scalars), np.nanmax(scalars)]
cs_cord = self.resultheader['csCord']
if cs_cord > 1:
matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix.Invert()
else:
matrix = vtk.vtkMatrix4x4()
i_matrix = vtk.vtkMatrix4x4()
rang = 360.0 / self.n_sector
for i in range(self.n_sector):
actor = plotter.add_mesh(grid.copy(False),
scalars=scalars[i], stitle=stitle,
cmap=cmap, flip_scalars=flip_scalars,
interpolate_before_map=True, rng=rng,
**kwargs)
# for transparency issues
# plotter.renderers[0].SetUseDepthPeeling(1)
# NAN/missing data are white
plotter.mapper.GetLookupTable().SetNanColor(1, 1, 1, 1)
# transform to standard position, rotate about Z axis,
# transform back
transform = vtk.vtkTransform()
transform.RotateZ(rang*i)
transform.Update()
rot_matrix = transform.GetMatrix()
if cs_cord > 1:
temp_matrix = vtk.vtkMatrix4x4()
rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix)
rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix)
transform.SetMatrix(rot_matrix)
actor.SetUserTransform(transform)
if cpos:
plotter.camera_position = cpos
# add table
if add_text and rnum is not None:
plotter.add_text(self.text_result_table(rnum), font_size=20,
position=[0, 0])
if screenshot:
cpos = plotter.show(auto_close=False, interactive=interactive,
window_size=window_size,
full_screen=full_screen)
if screenshot is True:
img = plotter.screenshot()
else:
plotter.screenshot(screenshot)
plotter.close()
else:
cpos = plotter.plot(window_size=window_size, full_screen=full_screen)
if screenshot is True:
return cpos, img
else:
return cpos
def quiver3d(self,
x,
y,
z,
u,
v,
w,
color,
scale,
mode,
resolution=8,
glyph_height=None,
glyph_center=None,
glyph_resolution=None,
opacity=1.0,
scale_mode='none',
scalars=None,
backface_culling=False,
line_width=2.,
name=None):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=FutureWarning)
factor = scale
vectors = np.c_[u, v, w]
points = np.vstack(np.c_[x, y, z])
n_points = len(points)
offset = np.arange(n_points) * 3
cell_type = np.full(n_points, vtk.VTK_VERTEX)
cells = np.c_[np.full(n_points, 1), range(n_points)]
grid = UnstructuredGrid(offset, cells, cell_type, points)
grid.point_arrays['vec'] = vectors
if scale_mode == 'scalar':
grid.point_arrays['mag'] = np.array(scalars)
scale = 'mag'
else:
scale = False
if mode == '2darrow':
return _arrow_glyph(grid, factor)
elif mode == 'arrow' or mode == '3darrow':
self.plotter.add_mesh(grid.glyph(orient='vec',
scale=scale,
factor=factor),
color=color,
opacity=opacity,
backface_culling=backface_culling)
elif mode == 'cone':
cone = vtk.vtkConeSource()
if glyph_height is not None:
cone.SetHeight(glyph_height)
if glyph_center is not None:
cone.SetCenter(glyph_center)
if glyph_resolution is not None:
cone.SetResolution(glyph_resolution)
cone.Update()
geom = cone.GetOutput()
self.plotter.add_mesh(grid.glyph(orient='vec',
scale=scale,
factor=factor,
geom=geom),
color=color,
opacity=opacity,
backface_culling=backface_culling)
elif mode == 'cylinder':
cylinder = vtk.vtkCylinderSource()
cylinder.SetHeight(glyph_height)
cylinder.SetRadius(0.15)
cylinder.SetCenter(glyph_center)
cylinder.SetResolution(glyph_resolution)
cylinder.Update()
# fix orientation
tr = vtk.vtkTransform()
tr.RotateWXYZ(90, 0, 0, 1)
trp = vtk.vtkTransformPolyDataFilter()
trp.SetInputData(cylinder.GetOutput())
trp.SetTransform(tr)
trp.Update()
geom = trp.GetOutput()
self.plotter.add_mesh(grid.glyph(orient='vec',
scale=scale,
factor=factor,
geom=geom),
color=color,
opacity=opacity,
backface_culling=backface_culling)
def main():
# Basic stuff setup
# Set up the renderer, window, and interactor
colors = vtk.vtkNamedColors()
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(640, 480)
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# Create a cone with an elliptical base whose major axis is in the
# X-direction.
coneSource = vtk.vtkConeSource()
coneSource.SetCenter(0.0, 0.0, 0.0)
coneSource.SetRadius(5.0)
coneSource.SetHeight(15.0)
coneSource.SetDirection(0, 1, 0)
coneSource.SetResolution(60)
coneSource.Update()
transform = vtk.vtkTransform()
transform.Scale(1.0, 1.0, 0.75)
transF = vtk.vtkTransformPolyDataFilter()
transF.SetInputConnection(coneSource.GetOutputPort())
transF.SetTransform(transform)
bounds = transF.GetOutput().GetBounds()
elevation = vtk.vtkElevationFilter()
elevation.SetInputConnection(transF.GetOutputPort())
elevation.SetLowPoint(0, bounds[2], 0)
elevation.SetHighPoint(0, bounds[3], 0)
bandedContours = vtk.vtkBandedPolyDataContourFilter()
bandedContours.SetInputConnection(elevation.GetOutputPort())
bandedContours.SetScalarModeToValue()
bandedContours.GenerateContourEdgesOn()
bandedContours.GenerateValues(11, elevation.GetScalarRange())
# Make a lookup table using a color series.
colorSeries = vtk.vtkColorSeries()
colorSeries.SetColorScheme(vtk.vtkColorSeries.BREWER_DIVERGING_SPECTRAL_11)
lut = vtk.vtkLookupTable()
colorSeries.BuildLookupTable(lut, vtk.vtkColorSeries.ORDINAL)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(bandedContours.GetOutputPort())
coneMapper.SetScalarRange(elevation.GetScalarRange())
coneMapper.SetLookupTable(lut)
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
# Contouring
contourLineMapper = vtk.vtkPolyDataMapper()
contourLineMapper.SetInputData(bandedContours.GetContourEdgesOutput())
contourLineMapper.SetScalarRange(elevation.GetScalarRange())
contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset()
contourLineActor = vtk.vtkActor()
contourLineActor.SetMapper(contourLineMapper)
contourLineActor.GetProperty().SetColor(colors.GetColor3d('DimGray'))
# Set up the Orientation Marker Widget.
prop_assembly = MakeAnnotatedCubeActor(colors)
om1 = vtk.vtkOrientationMarkerWidget()
om1.SetOrientationMarker(prop_assembly)
om1.SetInteractor(iRen)
om1.SetDefaultRenderer(ren)
om1.On()
om1.InteractiveOn()
xyzLabels = ['X', 'Y', 'Z']
scale = [1.0, 1.0, 1.0]
axes = MakeAxesActor(scale, xyzLabels)
om2 = vtk.vtkOrientationMarkerWidget()
om2.SetOrientationMarker(axes)
# Position lower right in the viewport.
om2.SetViewport(0.8, 0, 1.0, 0.2)
om2.SetInteractor(iRen)
om2.EnabledOn()
om2.InteractiveOn()
ren.AddActor(coneActor)
ren.AddActor(contourLineActor)
ren.SetBackground2(colors.GetColor3d('RoyalBlue'))
ren.SetBackground(colors.GetColor3d('MistyRose'))
ren.GradientBackgroundOn()
ren.GetActiveCamera().Azimuth(45)
ren.GetActiveCamera().Pitch(-22.5)
ren.ResetCamera()
renWin.SetSize(600, 600)
renWin.Render()
renWin.SetWindowName('ColoredAnnotatedCube')
renWin.Render()
iRen.Start()
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# create pipeline
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin")
pl3d.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin")
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
output = pl3d.GetOutput().GetBlock(0)
# create three line probes
line = vtk.vtkLineSource()
line.SetResolution(30)
transL1 = vtk.vtkTransform()
transL1.Translate(3.7, 0.0, 28.37)
transL1.Scale(5, 5, 5)
transL1.RotateY(90)
tf = vtk.vtkTransformPolyDataFilter()
tf.SetInputConnection(line.GetOutputPort())
tf.SetTransform(transL1)
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(tf.GetOutputPort())
probe.SetSourceData(output)
probe.Update()
transL2 = vtk.vtkTransform()
transL2.Translate(9.2, 0.0, 31.20)
transL2.Scale(5, 5, 5)
transL2.RotateY(90)
tf2 = vtk.vtkTransformPolyDataFilter()
def createModelBaseOnVolume(self, holefilledImageNode, outputModelNode):
if holefilledImageNode:
holefilledImageData = holefilledImageNode.GetImageData()
cast = vtk.vtkImageCast()
cast.SetInputData(holefilledImageData)
cast.SetOutputScalarTypeToUnsignedChar()
cast.Update()
labelVolumeNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLLabelMapVolumeNode")
slicer.mrmlScene.AddNode(labelVolumeNode)
labelVolumeNode.SetName("Threshold")
labelVolumeNode.SetSpacing(holefilledImageData.GetSpacing())
labelVolumeNode.SetOrigin(holefilledImageData.GetOrigin())
matrix = vtk.vtkMatrix4x4()
holefilledImageNode.GetIJKToRASMatrix(matrix)
labelVolumeNode.SetIJKToRASMatrix(matrix)
labelImage = cast.GetOutput()
labelVolumeNode.SetAndObserveImageData(labelImage)
transformIJKtoRAS = vtk.vtkTransform()
matrix = vtk.vtkMatrix4x4()
labelVolumeNode.GetRASToIJKMatrix(matrix)
transformIJKtoRAS.SetMatrix(matrix)
transformIJKtoRAS.Inverse()
padder = vtk.vtkImageConstantPad()
padder.SetInputData(labelImage)
padder.SetConstant(0)
extent = labelImage.GetExtent()
padder.SetOutputWholeExtent(extent[0], extent[1] + 2,
extent[2], extent[3] + 2,
extent[4], extent[5] + 2)
cubes = vtk.vtkDiscreteMarchingCubes()
cubes.SetInputConnection(padder.GetOutputPort())
cubes.GenerateValues(1, 1, 1)
cubes.Update()
smoother = vtk.vtkWindowedSincPolyDataFilter()
smoother.SetInputConnection(cubes.GetOutputPort())
smoother.SetNumberOfIterations(10)
smoother.BoundarySmoothingOn()
smoother.FeatureEdgeSmoothingOff()
smoother.SetFeatureAngle(120.0)
smoother.SetPassBand(0.001)
smoother.NonManifoldSmoothingOn()
smoother.NormalizeCoordinatesOn()
smoother.Update()
pthreshold = vtk.vtkThreshold()
pthreshold.SetInputConnection(smoother.GetOutputPort())
pthreshold.ThresholdBetween(1, 1) ## Label 1
pthreshold.ReleaseDataFlagOn()
geometryFilter = vtk.vtkGeometryFilter()
geometryFilter.SetInputConnection(pthreshold.GetOutputPort())
geometryFilter.ReleaseDataFlagOn()
decimator = vtk.vtkDecimatePro()
decimator.SetInputConnection(geometryFilter.GetOutputPort())
decimator.SetFeatureAngle(60)
decimator.SplittingOff()
decimator.PreserveTopologyOn()
decimator.SetMaximumError(1)
decimator.SetTargetReduction(0.5) #0.001 only reduce the points by 0.1%, 0.5 is 50% off
decimator.ReleaseDataFlagOff()
decimator.Update()
smootherPoly = vtk.vtkSmoothPolyDataFilter()
smootherPoly.SetRelaxationFactor(0.33)
smootherPoly.SetFeatureAngle(60)
smootherPoly.SetConvergence(0)
if transformIJKtoRAS.GetMatrix().Determinant() < 0:
reverser = vtk.vtkReverseSense()
reverser.SetInputConnection(decimator.GetOutputPort())
reverser.ReverseNormalsOn()
reverser.ReleaseDataFlagOn()
smootherPoly.SetInputConnection(reverser.GetOutputPort())
else:
smootherPoly.SetInputConnection(decimator.GetOutputPort())
Smooth = 10
smootherPoly.SetNumberOfIterations(Smooth)
smootherPoly.FeatureEdgeSmoothingOff()
smootherPoly.BoundarySmoothingOff()
smootherPoly.ReleaseDataFlagOn()
smootherPoly.Update()
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInputConnection(smootherPoly.GetOutputPort())
transformer.SetTransform(transformIJKtoRAS)
transformer.ReleaseDataFlagOn()
transformer.Update()
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(transformer.GetOutputPort())
normals.SetFeatureAngle(60)
normals.SetSplitting(True)
normals.ReleaseDataFlagOn()
stripper = vtk.vtkStripper()
stripper.SetInputConnection(normals.GetOutputPort())
stripper.ReleaseDataFlagOff()
stripper.Update()
outputModel = stripper.GetOutput()
outputModelNode.SetAndObservePolyData(outputModel)
outputModelNode.SetAttribute("vtkMRMLModelNode.modelCreated","True")
outputModelNode.GetDisplayNode().SetVisibility(1)
slicer.mrmlScene.RemoveNode(labelVolumeNode)
pass
def main():
filename = get_program_parameters()
# Create the reader for the data.
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(filename)
reader.Update()
bounds = reader.GetOutput().GetBounds()
center = reader.GetOutput().GetCenter()
colors = vtk.vtkNamedColors()
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('Wheat'))
renderer.UseHiddenLineRemovalOn()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
xnorm = [-1.0, -1.0, 1.0]
clipPlane = vtk.vtkPlane()
clipPlane.SetOrigin(reader.GetOutput().GetCenter())
clipPlane.SetNormal(xnorm)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(clipPlane)
clipper.SetInputData(reader.GetOutput())
clipper.SetValue(0.0)
clipper.GenerateClippedOutputOn()
clipper.Update()
insideMapper = vtk.vtkDataSetMapper()
insideMapper.SetInputData(clipper.GetOutput())
insideMapper.ScalarVisibilityOff()
insideActor = vtk.vtkActor()
insideActor.SetMapper(insideMapper)
insideActor.GetProperty().SetDiffuseColor(colors.GetColor3d('banana'))
insideActor.GetProperty().SetAmbient(.3)
insideActor.GetProperty().EdgeVisibilityOn()
clippedMapper = vtk.vtkDataSetMapper()
clippedMapper.SetInputData(clipper.GetClippedOutput())
clippedMapper.ScalarVisibilityOff()
clippedActor = vtk.vtkActor()
clippedActor.SetMapper(clippedMapper)
clippedActor.GetProperty().SetDiffuseColor(colors.GetColor3d('tomato'))
insideActor.GetProperty().SetAmbient(.3)
clippedActor.GetProperty().EdgeVisibilityOn()
# Create transforms to make a better visualization
insideTransform = vtk.vtkTransform()
insideTransform.Translate(-(bounds[1] - bounds[0]) * 0.75, 0, 0)
insideTransform.Translate(center[0], center[1], center[2])
insideTransform.RotateY(-120.0)
insideTransform.Translate(-center[0], -center[1], -center[2])
insideActor.SetUserTransform(insideTransform)
clippedTransform = vtk.vtkTransform()
clippedTransform.Translate((bounds[1] - bounds[0]) * 0.75, 0, 0)
clippedTransform.Translate(center[0], center[1], center[2])
clippedTransform.RotateY(60.0)
clippedTransform.Translate(-center[0], -center[1], -center[2])
clippedActor.SetUserTransform(clippedTransform)
renderer.AddViewProp(clippedActor)
renderer.AddViewProp(insideActor)
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(1.4)
renderer.ResetCameraClippingRange()
renderWindow.Render()
renderWindow.SetWindowName('ClipUnstructuredGridWithPlane2')
renderWindow.Render()
interactor.Start()
# Generate a report
numberOfCells = clipper.GetOutput().GetNumberOfCells()
print('------------------------')
print('The inside dataset contains a \n',
clipper.GetOutput().GetClassName(), ' that has ', numberOfCells,
' cells')
cellMap = dict()
for i in range(0, numberOfCells):
cellMap.setdefault(clipper.GetOutput().GetCellType(i), 0)
cellMap[clipper.GetOutput().GetCellType(i)] += 1
# Sort by key and put into an OrderedDict.
# An OrderedDict remembers the order in which the keys have been inserted.
for k, v in collections.OrderedDict(sorted(cellMap.items())).items():
print('\tCell type ', vtk.vtkCellTypes.GetClassNameFromTypeId(k),
' occurs ', v, ' times.')
numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
print('------------------------')
print('The clipped dataset contains a \n',
clipper.GetClippedOutput().GetClassName(), ' that has ',
numberOfCells, ' cells')
outsideCellMap = dict()
for i in range(0, numberOfCells):
outsideCellMap.setdefault(clipper.GetClippedOutput().GetCellType(i), 0)
outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] += 1
for k, v in collections.OrderedDict(sorted(
outsideCellMap.items())).items():
print('\tCell type ', vtk.vtkCellTypes.GetClassNameFromTypeId(k),
' occurs ', v, ' times.')
import vtk
'''<Reader>'''
reader = vtk.vtkStructuredGridReader()
reader.SetFileName('files/output.vtk')
reader.Update()
# 'Active' Scalar 지정 또는 변경(이미 default로 되어있는 경우)
varName = reader.GetOutput().GetPointData().GetArrayName(1)
reader.GetOutput().GetPointData().SetActiveScalars(varName)
rangeStart, rangeEnd = reader.GetOutput().GetScalarRange()
'''<Filter 1>'''
transformation = vtk.vtkTransform()
transformation.Scale(1, 1, 0.001)
Filter1 = vtk.vtkTransformFilter()
Filter1.SetInputConnection(reader.GetOutputPort())
Filter1.SetTransform(transformation)
'''<Filter 2>'''
Filter2 = vtk.vtkThreshold()
Filter2.ThresholdBetween(rangeStart, rangeEnd)
Filter2.SetInputConnection(Filter1.GetOutputPort())
'''<Mapper>'''
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(Filter2.GetOutputPort())
mapper.SetScalarRange(reader.GetOutput().GetScalarRange())
'''<Actor>'''
actor = vtk.vtkActor()
actor.SetMapper(mapper)
'''<Renderer>'''
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1)
def gen_surface(tomo, lbl=1, mask=True, purge_ratio=1, field=False,
mode_2d=False, verbose=False):
"""
Generates a VTK PolyData surface from a segmented tomogram.
Args:
tomo (numpy.ndarray or str): the input segmentation as numpy ndarray or
the file name in MRC, EM or VTI format
lbl (int, optional): label for the foreground, default 1
mask (boolean, optional): if True (default), the input segmentation is
used as mask for the surface
purge_ratio (int, optional): if greater than 1 (default), then 1 every
purge_ratio points of the segmentation are randomly deleted
field (boolean, optional): if True (default False), additionally returns
the polarity distance scalar field
mode_2d (boolean, optional): needed for polarity distance calculation
(if field is True), if True (default False), ...
verbose (boolean, optional): if True (default False), prints out
messages for checking the progress
Returns:
- output surface (vtk.vtkPolyData)
- polarity distance scalar field (np.ndarray), if field is True
"""
# Check input format
if isinstance(tomo, str):
fname, fext = os.path.splitext(tomo)
# if fext == '.fits':
# tomo = pyfits.getdata(tomo)
if fext == '.mrc':
hold = ImageIO()
hold.readMRC(file=tomo)
tomo = hold.data
elif fext == '.em':
hold = ImageIO()
hold.readEM(file=tomo)
tomo = hold.data
elif fext == '.vti':
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(tomo)
reader.Update()
tomo = vti_to_numpy(reader.GetOutput())
else:
error_msg = 'Format %s not readable.' % fext
raise pexceptions.PySegInputError(expr='gen_surface', msg=error_msg)
elif not isinstance(tomo, np.ndarray):
error_msg = 'Input must be either a file name or a ndarray.'
raise pexceptions.PySegInputError(expr='gen_surface', msg=error_msg)
# Load file with the cloud of points
nx, ny, nz = tomo.shape
cloud = vtk.vtkPolyData()
points = vtk.vtkPoints()
cloud.SetPoints(points)
if purge_ratio <= 1:
for x in range(nx):
for y in range(ny):
for z in range(nz):
if tomo[x, y, z] == lbl:
points.InsertNextPoint(x, y, z)
else:
count = 0
mx_value = purge_ratio - 1
purge = np.random.randint(0, purge_ratio+1, nx*ny*nz)
for x in range(nx):
for y in range(ny):
for z in range(nz):
if purge[count] == mx_value:
if tomo[x, y, z] == lbl:
points.InsertNextPoint(x, y, z)
count += 1
if verbose:
print 'Cloud of points loaded...'
# Creating the isosurface
surf = vtk.vtkSurfaceReconstructionFilter()
# surf.SetSampleSpacing(2)
surf.SetSampleSpacing(purge_ratio)
# surf.SetNeighborhoodSize(10)
surf.SetInputData(cloud)
contf = vtk.vtkContourFilter()
contf.SetInputConnection(surf.GetOutputPort())
# if thick is None:
contf.SetValue(0, 0)
# else:
# contf.SetValue(0, thick)
# Sometimes the contouring algorithm can create a volume whose gradient
# vector and ordering of polygon (using the right hand rule) are
# inconsistent. vtkReverseSense cures this problem.
reverse = vtk.vtkReverseSense()
reverse.SetInputConnection(contf.GetOutputPort())
reverse.ReverseCellsOn()
reverse.ReverseNormalsOn()
reverse.Update()
rsurf = reverse.GetOutput()
if verbose:
print 'Isosurfaces generated...'
# Translate and scale to the proper positions
cloud.ComputeBounds()
rsurf.ComputeBounds()
xmin, xmax, ymin, ymax, zmin, zmax = cloud.GetBounds()
rxmin, rxmax, rymin, rymax, rzmin, rzmax = rsurf.GetBounds()
scale_x = (xmax-xmin) / (rxmax-rxmin)
scale_y = (ymax-ymin) / (rymax-rymin)
denom = rzmax - rzmin
num = zmax - xmin
if (denom == 0) or (num == 0):
scale_z = 1
else:
scale_z = (zmax-zmin) / (rzmax-rzmin)
transp = vtk.vtkTransform()
transp.Translate(xmin, ymin, zmin)
transp.Scale(scale_x, scale_y, scale_z)
transp.Translate(-rxmin, -rymin, -rzmin)
tpd = vtk.vtkTransformPolyDataFilter()
tpd.SetInputData(rsurf)
tpd.SetTransform(transp)
tpd.Update()
tsurf = tpd.GetOutput()
if verbose:
print 'Rescaled and translated...'
# Masking according to distance to the original segmentation
if mask:
tomod = scipy.ndimage.morphology.distance_transform_edt(
np.invert(tomo == lbl))
for i in range(tsurf.GetNumberOfCells()):
# Check if all points which made up the polygon are in the mask
points_cell = tsurf.GetCell(i).GetPoints()
count = 0
for j in range(0, points_cell.GetNumberOfPoints()):
x, y, z = points_cell.GetPoint(j)
if (tomod[int(round(x)), int(round(y)), int(round(z))]
> MAX_DIST_SURF):
count += 1
if count > 0:
tsurf.DeleteCell(i)
# Release free memory
tsurf.RemoveDeletedCells()
if verbose:
print 'Mask applied...'
# Field distance
if field:
# Get normal attributes
norm_flt = vtk.vtkPolyDataNormals()
norm_flt.SetInputData(tsurf)
norm_flt.ComputeCellNormalsOn()
norm_flt.AutoOrientNormalsOn()
norm_flt.ConsistencyOn()
norm_flt.Update()
tsurf = norm_flt.GetOutput()
# for i in range(tsurf.GetPointData().GetNumberOfArrays()):
# array = tsurf.GetPointData().GetArray(i)
# if array.GetNumberOfComponents() == 3:
# break
array = tsurf.GetCellData().GetNormals()
# Build membrane mask
tomoh = np.ones(shape=tomo.shape, dtype=np.bool)
tomon = np.ones(shape=(tomo.shape[0], tomo.shape[1], tomo.shape[2], 3),
dtype=TypesConverter().vtk_to_numpy(array))
# for i in range(tsurf.GetNumberOfCells()):
# points_cell = tsurf.GetCell(i).GetPoints()
# for j in range(0, points_cell.GetNumberOfPoints()):
# x, y, z = points_cell.GetPoint(j)
# # print x, y, z, array.GetTuple(j)
# x, y, z = int(round(x)), int(round(y)), int(round(z))
# tomo[x, y, z] = False
# tomon[x, y, z, :] = array.GetTuple(j)
for i in range(tsurf.GetNumberOfCells()):
points_cell = tsurf.GetCell(i).GetPoints()
for j in range(0, points_cell.GetNumberOfPoints()):
x, y, z = points_cell.GetPoint(j)
# print x, y, z, array.GetTuple(j)
x, y, z = int(round(x)), int(round(y)), int(round(z))
if tomo[x, y, z] == lbl:
tomoh[x, y, z] = False
tomon[x, y, z, :] = array.GetTuple(i)
# Distance transform
tomod, ids = scipy.ndimage.morphology.distance_transform_edt(
tomoh, return_indices=True)
# Compute polarity
if mode_2d:
for x in range(nx):
for y in range(ny):
for z in range(nz):
i_x, i_y, i_z = (ids[0, x, y, z], ids[1, x, y, z],
ids[2, x, y, z])
norm = tomon[i_x, i_y, i_z]
norm[2] = 0
pnorm = (i_x, i_y, 0)
p = (x, y, 0)
dprod = dot_norm(np.asarray(p, dtype=np.float),
np.asarray(pnorm, dtype=np.float),
np.asarray(norm, dtype=np.float))
tomod[x, y, z] = tomod[x, y, z] * np.sign(dprod)
else:
for x in range(nx):
for y in range(ny):
for z in range(nz):
i_x, i_y, i_z = (ids[0, x, y, z], ids[1, x, y, z],
ids[2, x, y, z])
hold_norm = tomon[i_x, i_y, i_z]
norm = hold_norm
# norm[0] = (-1) * hold_norm[1]
# norm[1] = hold_norm[0]
# norm[2] = hold_norm[2]
pnorm = (i_x, i_y, i_z)
p = (x, y, z)
dprod = dot_norm(np.asarray(pnorm, dtype=np.float),
np.asarray(p, dtype=np.float),
np.asarray(norm, dtype=np.float))
tomod[x, y, z] = tomod[x, y, z] * np.sign(dprod)
if verbose:
print 'Distance field generated...'
return tsurf, tomod
if verbose:
print 'Finished!'
return tsurf
def main():
colors = vtk.vtkNamedColors()
# Set the colors.
colors.SetColor("AzimuthArrowColor", [255, 77, 77, 255])
colors.SetColor("ElevationArrowColor", [77, 255, 77, 255])
colors.SetColor("RollArrowColor", [255, 255, 77, 255])
colors.SetColor("SpikeColor", [255, 77, 255, 255])
colors.SetColor("BkgColor", [26, 51, 102, 255])
# Create a rendering window, renderer and interactor.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create a camera model.
camCS = vtk.vtkConeSource()
camCS.SetHeight(1.5)
camCS.SetResolution(12)
camCS.SetRadius(0.4)
camCBS = vtk.vtkCubeSource()
camCBS.SetXLength(1.5)
camCBS.SetZLength(0.8)
camCBS.SetCenter(0.4, 0, 0)
camAPD = vtk.vtkAppendFilter()
camAPD.AddInputConnection(camCBS.GetOutputPort())
camAPD.AddInputConnection(camCS.GetOutputPort())
camMapper = vtk.vtkPolyDataMapper()
camMapper.SetInputConnection(camAPD.GetOutputPort())
camActor = vtk.vtkLODActor()
camActor.SetMapper(camMapper)
camActor.SetScale(2, 2, 2)
# Draw the arrows.
pd = vtk.vtkPolyData()
ca = vtk.vtkCellArray()
fp = vtk.vtkPoints()
fp.InsertNextPoint(0, 1, 0)
fp.InsertNextPoint(8, 1, 0)
fp.InsertNextPoint(8, 2, 0)
fp.InsertNextPoint(10, 0.01, 0)
fp.InsertNextPoint(8, -2, 0)
fp.InsertNextPoint(8, -1, 0)
fp.InsertNextPoint(0, -1, 0)
ca.InsertNextCell(7)
ca.InsertCellPoint(0)
ca.InsertCellPoint(1)
ca.InsertCellPoint(2)
ca.InsertCellPoint(3)
ca.InsertCellPoint(4)
ca.InsertCellPoint(5)
ca.InsertCellPoint(6)
pd.SetPoints(fp)
pd.SetPolys(ca)
pd2 = vtk.vtkPolyData()
ca2 = vtk.vtkCellArray()
fp2 = vtk.vtkPoints()
fp2.InsertNextPoint(0, 1, 0)
fp2.InsertNextPoint(8, 1, 0)
fp2.InsertNextPoint(8, 2, 0)
fp2.InsertNextPoint(10, 0.01, 0)
ca2.InsertNextCell(4)
ca2.InsertCellPoint(0)
ca2.InsertCellPoint(1)
ca2.InsertCellPoint(2)
ca2.InsertCellPoint(3)
pd2.SetPoints(fp2)
pd2.SetLines(ca2)
arrowIM = vtk.vtkImplicitModeller()
arrowIM.SetInputData(pd)
arrowIM.SetSampleDimensions(50, 20, 8)
arrowCF = vtk.vtkContourFilter()
arrowCF.SetInputConnection(arrowIM.GetOutputPort())
arrowCF.SetValue(0, 0.2)
arrowWT = vtk.vtkWarpTo()
arrowWT.SetInputConnection(arrowCF.GetOutputPort())
arrowWT.SetPosition(5, 0, 5)
arrowWT.SetScaleFactor(0.85)
arrowWT.AbsoluteOn()
arrowT = vtk.vtkTransform()
arrowT.RotateY(60)
arrowT.Translate(-1.33198, 0, -1.479)
arrowT.Scale(1, 0.5, 1)
arrowTF = vtk.vtkTransformFilter()
arrowTF.SetInputConnection(arrowWT.GetOutputPort())
arrowTF.SetTransform(arrowT)
arrowMapper = vtk.vtkDataSetMapper()
arrowMapper.SetInputConnection(arrowTF.GetOutputPort())
arrowMapper.ScalarVisibilityOff()
# Draw the azimuth arrows.
a1Actor = vtk.vtkLODActor()
a1Actor.SetMapper(arrowMapper)
a1Actor.RotateZ(180)
a1Actor.SetPosition(1, 0, -1)
a1Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor"))
a1Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
a1Actor.GetProperty().SetSpecular(0.3)
a1Actor.GetProperty().SetSpecularPower(20)
a1Actor.GetProperty().SetAmbient(0.2)
a1Actor.GetProperty().SetDiffuse(0.8)
a2Actor = vtk.vtkLODActor()
a2Actor.SetMapper(arrowMapper)
a2Actor.RotateZ(180)
a2Actor.RotateX(180)
a2Actor.SetPosition(1, 0, 1)
a2Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor"))
a2Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
a2Actor.GetProperty().SetSpecular(0.3)
a2Actor.GetProperty().SetSpecularPower(20)
a2Actor.GetProperty().SetAmbient(0.2)
a2Actor.GetProperty().SetDiffuse(0.8)
# Draw the elevation arrows.
a3Actor = vtk.vtkLODActor()
a3Actor.SetMapper(arrowMapper)
a3Actor.RotateZ(180)
a3Actor.RotateX(90)
a3Actor.SetPosition(1, -1, 0)
a3Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor"))
a3Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
a3Actor.GetProperty().SetSpecular(0.3)
a3Actor.GetProperty().SetSpecularPower(20)
a3Actor.GetProperty().SetAmbient(0.2)
a3Actor.GetProperty().SetDiffuse(0.8)
a4Actor = vtk.vtkLODActor()
a4Actor.SetMapper(arrowMapper)
a4Actor.RotateZ(180)
a4Actor.RotateX(-90)
a4Actor.SetPosition(1, 1, 0)
a4Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor"))
a4Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
a4Actor.GetProperty().SetSpecular(0.3)
a4Actor.GetProperty().SetSpecularPower(20)
a4Actor.GetProperty().SetAmbient(0.2)
a4Actor.GetProperty().SetDiffuse(0.8)
# Draw the DOP.
arrowT2 = vtk.vtkTransform()
arrowT2.Scale(1, 0.6, 1)
arrowT2.RotateY(90)
arrowTF2 = vtk.vtkTransformPolyDataFilter()
arrowTF2.SetInputData(pd2)
arrowTF2.SetTransform(arrowT2)
arrowREF = vtk.vtkRotationalExtrusionFilter()
arrowREF.SetInputConnection(arrowTF2.GetOutputPort())
arrowREF.CappingOff()
arrowREF.SetResolution(30)
spikeMapper = vtk.vtkPolyDataMapper()
spikeMapper.SetInputConnection(arrowREF.GetOutputPort())
a5Actor = vtk.vtkLODActor()
a5Actor.SetMapper(spikeMapper)
a5Actor.SetScale(.3, .3, .6)
a5Actor.RotateY(90)
a5Actor.SetPosition(-2, 0, 0)
a5Actor.GetProperty().SetColor(colors.GetColor3d("SpikeColor"))
a5Actor.GetProperty().SetAmbient(0.2)
a5Actor.GetProperty().SetDiffuse(0.8)
# Focal point.
fps = vtk.vtkSphereSource()
fps.SetRadius(0.5)
fpMapper = vtk.vtkPolyDataMapper()
fpMapper.SetInputConnection(fps.GetOutputPort())
fpActor = vtk.vtkLODActor()
fpActor.SetMapper(fpMapper)
fpActor.SetPosition(-9, 0, 0)
fpActor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
fpActor.GetProperty().SetSpecular(0.3)
fpActor.GetProperty().SetAmbient(0.2)
fpActor.GetProperty().SetDiffuse(0.8)
fpActor.GetProperty().SetSpecularPower(20)
# Create the roll arrows.
arrowWT2 = vtk.vtkWarpTo()
arrowWT2.SetInputConnection(arrowCF.GetOutputPort())
arrowWT2.SetPosition(5, 0, 2.5)
arrowWT2.SetScaleFactor(0.95)
arrowWT2.AbsoluteOn()
arrowT3 = vtk.vtkTransform()
arrowT3.Translate(-2.50358, 0, -1.70408)
arrowT3.Scale(0.5, 0.3, 1)
arrowTF3 = vtk.vtkTransformFilter()
arrowTF3.SetInputConnection(arrowWT2.GetOutputPort())
arrowTF3.SetTransform(arrowT3)
arrowMapper2 = vtk.vtkDataSetMapper()
arrowMapper2.SetInputConnection(arrowTF3.GetOutputPort())
arrowMapper2.ScalarVisibilityOff()
# Draw the roll arrows.
a6Actor = vtk.vtkLODActor()
a6Actor.SetMapper(arrowMapper2)
a6Actor.RotateZ(90)
a6Actor.SetPosition(-4, 0, 0)
a6Actor.SetScale(1.5, 1.5, 1.5)
a6Actor.GetProperty().SetColor(colors.GetColor3d("RollArrowColor"))
a6Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White"))
a6Actor.GetProperty().SetSpecular(0.3)
a6Actor.GetProperty().SetSpecularPower(20)
a6Actor.GetProperty().SetAmbient(0.2)
a6Actor.GetProperty().SetDiffuse(0.8)
# Add the actors to the renderer, set the background and size.
ren.AddActor(camActor)
ren.AddActor(a1Actor)
ren.AddActor(a2Actor)
ren.AddActor(a3Actor)
ren.AddActor(a4Actor)
ren.AddActor(a5Actor)
ren.AddActor(a6Actor)
ren.AddActor(fpActor)
ren.SetBackground(colors.GetColor3d("BkgColor"))
ren.SetBackground(colors.GetColor3d("SlateGray"))
renWin.SetSize(640, 480)
# Render the image.
cam1 = (ren.GetActiveCamera())
ren.ResetCamera()
cam1.Azimuth(150)
cam1.Elevation(30)
cam1.Dolly(1.5)
ren.ResetCameraClippingRange()
# Create a TextActor for azimuth (a1 and a2 actor's color).
text = vtk.vtkTextActor()
text.SetInput("Azimuth")
tprop = text.GetTextProperty()
tprop.SetFontFamilyToArial()
tprop.ShadowOff()
tprop.SetLineSpacing(1.0)
tprop.SetFontSize(36)
tprop.SetColor(a1Actor.GetProperty().GetColor())
text.SetDisplayPosition(20, 50)
ren.AddActor2D(text)
# Create a TextActor for elevation (a3 and a4 actor's color).
text2 = vtk.vtkTextActor()
text2.SetInput("Elevation")
tprop = text2.GetTextProperty()
tprop.SetFontFamilyToArial()
tprop.ShadowOff()
tprop.SetLineSpacing(1.0)
tprop.SetFontSize(36)
tprop.SetColor(a3Actor.GetProperty().GetColor())
text2.SetDisplayPosition(20, 100)
ren.AddActor2D(text2)
# Create a TextActor for roll (a6 actor's color).
text3 = vtk.vtkTextActor()
text3.SetInput("Roll")
tprop = text3.GetTextProperty()
tprop.SetFontFamilyToArial()
tprop.ShadowOff()
tprop.SetLineSpacing(1.0)
tprop.SetFontSize(36)
tprop.SetColor(a6Actor.GetProperty().GetColor())
text3.SetDisplayPosition(20, 150)
ren.AddActor2D(text3)
iren.Initialize()
iren.Start()
if len(args) != 3:
p.print_help()
sys.exit(1)
(in_file, grid_file, out_file) = args
# work out readers and writers to use
if in_file.endswith(".vtu"):
old_mesh_reader = vtk.vtkXMLUnstructuredGridReader()
elif in_file.endswith(".vtp"):
old_mesh_reader = vtk.vtkXMLPolyDataReader()
else:
print "Program not yet configured for type of input file", in_file
sys.exit(2)
# to get rid of z values
flattener = vtk.vtkTransform()
flattener.Scale(1.0, 1.0, 0.0)
# read the input and the source
if opts.verbose: print "Reading", in_file
old_mesh_reader.SetFileName(in_file)
old_mesh_reader.Update()
data = old_mesh_reader.GetOutput()
data_flat = vtk.vtkTransformFilter()
data_flat.SetInput(data)
data_flat.SetTransform(flattener)
data_flat.Update()
data_flat = data_flat.GetOutput()
if opts.verbose: print "Reading mesh"
rect_grid_reader = vtk.vtkXMLRectilinearGridReader()
def quiver3d(self,
x,
y,
z,
u,
v,
w,
color,
scale,
mode,
resolution=8,
glyph_height=None,
glyph_center=None,
glyph_resolution=None,
opacity=1.0,
scale_mode='none',
scalars=None,
backface_culling=False,
line_width=2.,
name=None,
glyph_width=None,
glyph_depth=None,
solid_transform=None):
_check_option('mode', mode, ALLOWED_QUIVER_MODES)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=FutureWarning)
factor = scale
vectors = np.c_[u, v, w]
points = np.vstack(np.c_[x, y, z])
n_points = len(points)
cell_type = np.full(n_points, vtk.VTK_VERTEX)
cells = np.c_[np.full(n_points, 1), range(n_points)]
args = (cells, cell_type, points)
if not VTK9:
args = (np.arange(n_points) * 3, ) + args
grid = UnstructuredGrid(*args)
_point_data(grid)['vec'] = vectors
if scale_mode == 'scalar':
_point_data(grid)['mag'] = np.array(scalars)
scale = 'mag'
else:
scale = False
if mode == '2darrow':
return _arrow_glyph(grid, factor), grid
elif mode == 'arrow':
alg = _glyph(grid, orient='vec', scalars=scale, factor=factor)
mesh = pyvista.wrap(alg.GetOutput())
else:
tr = None
if mode == 'cone':
glyph = vtk.vtkConeSource()
glyph.SetCenter(0.5, 0, 0)
glyph.SetRadius(0.15)
elif mode == 'cylinder':
glyph = vtk.vtkCylinderSource()
glyph.SetRadius(0.15)
elif mode == 'oct':
glyph = vtk.vtkPlatonicSolidSource()
glyph.SetSolidTypeToOctahedron()
else:
assert mode == 'sphere', mode # guaranteed above
glyph = vtk.vtkSphereSource()
if mode == 'cylinder':
if glyph_height is not None:
glyph.SetHeight(glyph_height)
if glyph_center is not None:
glyph.SetCenter(glyph_center)
if glyph_resolution is not None:
glyph.SetResolution(glyph_resolution)
tr = vtk.vtkTransform()
tr.RotateWXYZ(90, 0, 0, 1)
elif mode == 'oct':
if solid_transform is not None:
assert solid_transform.shape == (4, 4)
tr = vtk.vtkTransform()
tr.SetMatrix(
solid_transform.astype(np.float64).ravel())
if tr is not None:
# fix orientation
glyph.Update()
trp = vtk.vtkTransformPolyDataFilter()
trp.SetInputData(glyph.GetOutput())
trp.SetTransform(tr)
glyph = trp
glyph.Update()
geom = glyph.GetOutput()
mesh = grid.glyph(orient='vec',
scale=scale,
factor=factor,
geom=geom)
actor = _add_mesh(self.plotter,
mesh=mesh,
color=color,
opacity=opacity,
backface_culling=backface_culling)
return actor, mesh
def CreateSurface9076(): # Coordinate transformations # Sensor from STL sensorFromSTL = vtk.vtkTransform()
def marching_cubes(mcCases):
color = vtk.vtkNamedColors()
renWin = vtk.vtkRenderWindow()
renWin.SetSize(640, 480)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renderers = list()
gridSize = ((len(mcCases) + 3) // 4) * 4
if len(mcCases) < 4:
gridSize = len(mcCases)
print("gridSize:", gridSize)
for i in range(0, gridSize):
# Create the Renderer
renderer = vtk.vtkRenderer()
renderers.append(renderer)
renWin.AddRenderer(renderer)
for i in range(0, len(mcCases)):
# Define a Single Cube
Scalars = vtk.vtkFloatArray()
Scalars.InsertNextValue(1.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(1.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Scalars.InsertNextValue(0.0)
Points = vtk.vtkPoints()
Points.InsertNextPoint(0, 0, 0)
Points.InsertNextPoint(1, 0, 0)
Points.InsertNextPoint(1, 1, 0)
Points.InsertNextPoint(0, 1, 0)
Points.InsertNextPoint(0, 0, 1)
Points.InsertNextPoint(1, 0, 1)
Points.InsertNextPoint(1, 1, 1)
Points.InsertNextPoint(0, 1, 1)
Ids = vtk.vtkIdList()
Ids.InsertNextId(0)
Ids.InsertNextId(1)
Ids.InsertNextId(2)
Ids.InsertNextId(3)
Ids.InsertNextId(4)
Ids.InsertNextId(5)
Ids.InsertNextId(6)
Ids.InsertNextId(7)
Grid = vtk.vtkUnstructuredGrid()
Grid.Allocate(10, 10)
Grid.InsertNextCell(12, Ids)
Grid.SetPoints(Points)
Grid.GetPointData().SetScalars(Scalars)
# Find the triangles that lie along the 0.5 contour in this cube.
Marching = vtk.vtkContourFilter()
Marching.SetInputData(Grid)
Marching.SetValue(0, 0.5)
Marching.Update()
# Extract the edges of the triangles just found.
triangleEdges = vtk.vtkExtractEdges()
triangleEdges.SetInputConnection(Marching.GetOutputPort())
# Draw the edges as tubes instead of lines. Also create the associated
# mapper and actor to display the tubes.
triangleEdgeTubes = vtk.vtkTubeFilter()
triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort())
triangleEdgeTubes.SetRadius(.005)
triangleEdgeTubes.SetNumberOfSides(6)
triangleEdgeTubes.UseDefaultNormalOn()
triangleEdgeTubes.SetDefaultNormal(.577, .577, .577)
triangleEdgeMapper = vtk.vtkPolyDataMapper()
triangleEdgeMapper.SetInputConnection(
triangleEdgeTubes.GetOutputPort())
triangleEdgeMapper.ScalarVisibilityOff()
triangleEdgeActor = vtk.vtkActor()
triangleEdgeActor.SetMapper(triangleEdgeMapper)
triangleEdgeActor.GetProperty().SetDiffuseColor(
color.GetColor3d("lamp_black"))
triangleEdgeActor.GetProperty().SetSpecular(.4)
triangleEdgeActor.GetProperty().SetSpecularPower(10)
# Shrink the triangles we found earlier. Create the associated mapper
# and actor. Set the opacity of the shrunken triangles.
aShrinker = vtk.vtkShrinkPolyData()
aShrinker.SetShrinkFactor(1)
aShrinker.SetInputConnection(Marching.GetOutputPort())
aMapper = vtk.vtkPolyDataMapper()
aMapper.ScalarVisibilityOff()
aMapper.SetInputConnection(aShrinker.GetOutputPort())
Triangles = vtk.vtkActor()
Triangles.SetMapper(aMapper)
Triangles.GetProperty().SetDiffuseColor(color.GetColor3d("banana"))
Triangles.GetProperty().SetOpacity(.6)
# Draw a cube the same size and at the same position as the one
# created previously. Extract the edges because we only want to see
# the outline of the cube. Pass the edges through a vtkTubeFilter so
# they are displayed as tubes rather than lines.
CubeModel = vtk.vtkCubeSource()
CubeModel.SetCenter(.5, .5, .5)
Edges = vtk.vtkExtractEdges()
Edges.SetInputConnection(CubeModel.GetOutputPort())
Tubes = vtk.vtkTubeFilter()
Tubes.SetInputConnection(Edges.GetOutputPort())
Tubes.SetRadius(.01)
Tubes.SetNumberOfSides(6)
Tubes.UseDefaultNormalOn()
Tubes.SetDefaultNormal(.577, .577, .577)
# Create the mapper and actor to display the cube edges.
TubeMapper = vtk.vtkPolyDataMapper()
TubeMapper.SetInputConnection(Tubes.GetOutputPort())
CubeEdges = vtk.vtkActor()
CubeEdges.SetMapper(TubeMapper)
CubeEdges.GetProperty().SetDiffuseColor(color.GetColor3d("khaki"))
CubeEdges.GetProperty().SetSpecular(.4)
CubeEdges.GetProperty().SetSpecularPower(10)
# Create a sphere to use as a glyph source for vtkGlyph3D.
Sphere = vtk.vtkSphereSource()
Sphere.SetRadius(0.04)
Sphere.SetPhiResolution(20)
Sphere.SetThetaResolution(20)
# Remove the part of the cube with data values below 0.5.
ThresholdIn = vtk.vtkThresholdPoints()
ThresholdIn.SetInputData(Grid)
ThresholdIn.ThresholdByUpper(.5)
# Display spheres at the vertices remaining in the cube data set after
# it was passed through vtkThresholdPoints.
Vertices = vtk.vtkGlyph3D()
Vertices.SetInputConnection(ThresholdIn.GetOutputPort())
Vertices.SetSourceConnection(Sphere.GetOutputPort())
# Create a mapper and actor to display the glyphs.
SphereMapper = vtk.vtkPolyDataMapper()
SphereMapper.SetInputConnection(Vertices.GetOutputPort())
SphereMapper.ScalarVisibilityOff()
CubeVertices = vtk.vtkActor()
CubeVertices.SetMapper(SphereMapper)
CubeVertices.GetProperty().SetDiffuseColor(color.GetColor3d("tomato"))
# Define the text for the label
caseLabel = vtk.vtkVectorText()
caseLabel.SetText("Case 1")
# Set up a transform to move the label to a new position.
aLabelTransform = vtk.vtkTransform()
aLabelTransform.Identity()
aLabelTransform.Translate(-0.2, 0, 1.25)
aLabelTransform.Scale(.05, .05, .05)
# Move the label to a new position.
labelTransform = vtk.vtkTransformPolyDataFilter()
labelTransform.SetTransform(aLabelTransform)
labelTransform.SetInputConnection(caseLabel.GetOutputPort())
# Create a mapper and actor to display the text.
labelMapper = vtk.vtkPolyDataMapper()
labelMapper.SetInputConnection(labelTransform.GetOutputPort())
labelActor = vtk.vtkActor()
labelActor.SetMapper(labelMapper)
# Define the base that the cube sits on. Create its associated mapper
# and actor. Set the position of the actor.
baseModel = vtk.vtkCubeSource()
baseModel.SetXLength(1.5)
baseModel.SetYLength(.01)
baseModel.SetZLength(1.5)
baseMapper = vtk.vtkPolyDataMapper()
baseMapper.SetInputConnection(baseModel.GetOutputPort())
base = vtk.vtkActor()
base.SetMapper(baseMapper)
base.SetPosition(.5, -0.09, .5)
# Set the scalar values for this case of marching cubes.
# A negative case number will generate a complementary case
mcCase = mcCases[i]
if mcCase < 0:
cases[-mcCase](Scalars, caseLabel, 0, 1)
else:
cases[mcCase](Scalars, caseLabel, 1, 0)
# Force the grid to update.
Grid.Modified()
# Add the actors to the renderer
renderers[i].AddActor(triangleEdgeActor)
renderers[i].AddActor(base)
renderers[i].AddActor(labelActor)
renderers[i].AddActor(CubeEdges)
renderers[i].AddActor(CubeVertices)
renderers[i].AddActor(Triangles)
# Set the background color.
renderers[i].SetBackground(color.GetColor3d("slate_grey"))
# Position the camera.
renderers[i].GetActiveCamera().Dolly(1.2)
renderers[i].GetActiveCamera().Azimuth(30)
renderers[i].GetActiveCamera().Elevation(20)
renderers[i].ResetCamera()
renderers[i].ResetCameraClippingRange()
if i > 0:
renderers[i].SetActiveCamera(renderers[0].GetActiveCamera())
# Setup viewports for the renderers
rendererSize = 300
xGridDimensions = 4
if len(mcCases) < 4:
xGridDimensions = len(mcCases)
yGridDimensions = (len(mcCases) - 1) // 4 + 1
print("x, y:", xGridDimensions, ",", yGridDimensions)
renWin.SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions)
for row in range(0, yGridDimensions):
for col in range(0, xGridDimensions):
index = row * xGridDimensions + col
# (xmin, ymin, xmax, ymax)
viewport = [
float(col) / xGridDimensions,
float(yGridDimensions - (row + 1)) / yGridDimensions,
float(col + 1) / xGridDimensions,
float(yGridDimensions - row) / yGridDimensions
]
renderers[index].SetViewport(viewport)
iren.Initialize()
renWin.Render()
iren.Start()
def doWrap(Act, wc, wrap=[0., 360]):
if wrap is None:
return Act
Mapper = Act.GetMapper()
data = Mapper.GetInput()
xmn = min(wc[0], wc[1])
xmx = max(wc[0], wc[1])
if numpy.allclose(xmn, 1.e20) or numpy.allclose(xmx, 1.e20):
xmx = abs(wrap[1])
xmn = -wrap[1]
ymn = min(wc[2], wc[3])
ymx = max(wc[2], wc[3])
if numpy.allclose(ymn, 1.e20) or numpy.allclose(ymx, 1.e20):
ymx = abs(wrap[0])
ymn = -wrap[0]
## Prepare MultiBlock and puts in oriinal data
appendFilter = vtk.vtkAppendPolyData()
appendFilter.AddInputData(data)
appendFilter.Update()
## X axis wrappping
Amn, Amx = Act.GetXRange()
if wrap[1] != 0.:
i = 0
while Amn > xmn:
i += 1
Amn -= wrap[1]
Tpf = vtk.vtkTransformPolyDataFilter()
Tpf.SetInputData(data)
T = vtk.vtkTransform()
T.Translate(-i * wrap[1], 0, 0)
Tpf.SetTransform(T)
Tpf.Update()
appendFilter.AddInputData(Tpf.GetOutput())
appendFilter.Update()
i = 0
while Amx < xmx:
i += 1
Amx += wrap[1]
Tpf = vtk.vtkTransformPolyDataFilter()
Tpf.SetInputData(data)
T = vtk.vtkTransform()
T.Translate(i * wrap[1], 0, 0)
Tpf.SetTransform(T)
Tpf.Update()
appendFilter.AddInputData(Tpf.GetOutput())
appendFilter.Update()
# Y axis wrapping
Amn, Amx = Act.GetYRange()
if wrap[0] != 0.:
i = 0
while Amn > ymn:
i += 1
Amn -= wrap[0]
Tpf = vtk.vtkTransformPolyDataFilter()
Tpf.SetInputData(data)
T = vtk.vtkTransform()
T.Translate(0, i * wrap[0], 0)
Tpf.SetTransform(T)
Tpf.Update()
appendFilter.AddInputData(Tpf.GetOutput())
appendFilter.Update()
i = 0
while Amx < ymx:
i += 1
Amx += wrap[0]
Tpf = vtk.vtkTransformPolyDataFilter()
Tpf.SetInputData(data)
T = vtk.vtkTransform()
T.Translate(0, -i * wrap[0], 0)
Tpf.SetTransform(T)
Tpf.Update()
appendFilter.AddInputData(Tpf.GetOutput())
appendFilter.Update()
appendFilter.Update()
Actor = vtk.vtkActor()
Actor.SetProperty(Act.GetProperty())
#Mapper2 = vtk.vtkDataSetMapper()
#Mapper2 = vtk.vtkCompositePolyDataMapper()
Mapper2 = vtk.vtkPolyDataMapper()
Mapper2.SetInputData(appendFilter.GetOutput())
Mapper2.SetLookupTable(Mapper.GetLookupTable())
Mapper2.SetScalarRange(Mapper.GetScalarRange())
Mapper2.SetScalarMode(Mapper.GetScalarMode())
setClipPlanes(Mapper2, xmn, xmx, ymn, ymx)
Mapper2.Update()
Actor.SetMapper(Mapper2)
return Actor
def CreateSurfaceFromPolydata(self,
polydata,
overwrite=False,
name=None,
colour=None,
transparency=None,
volume=None,
area=None,
scalar=False):
if self.converttoInV and self.affine is not None:
transform = vtk.vtkTransform()
transform.SetMatrix(self.affine)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputData(polydata)
transformFilter.Update()
polydata = transformFilter.GetOutput()
self.converttoInV = None
normals = vtk.vtkPolyDataNormals()
normals.SetInputData(polydata)
normals.SetFeatureAngle(80)
normals.AutoOrientNormalsOn()
normals.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(normals.GetOutput())
if scalar:
mapper.ScalarVisibilityOn()
else:
mapper.ScalarVisibilityOff()
mapper.ImmediateModeRenderingOn() # improve performance
actor = vtk.vtkActor()
actor.SetMapper(mapper)
print("BOunds", actor.GetBounds())
if overwrite:
surface = Surface(index=self.last_surface_index)
else:
surface = Surface()
if not colour:
surface.colour = random.choice(const.SURFACE_COLOUR)
else:
surface.colour = colour
surface.polydata = polydata
if transparency:
surface.transparency = transparency
if name:
surface.name = name
# Append surface into Project.surface_dict
proj = prj.Project()
if overwrite:
proj.ChangeSurface(surface)
else:
index = proj.AddSurface(surface)
surface.index = index
self.last_surface_index = index
# Set actor colour and transparency
actor.GetProperty().SetColor(surface.colour)
actor.GetProperty().SetOpacity(1 - surface.transparency)
self.actors_dict[surface.index] = actor
session = ses.Session()
session.ChangeProject()
# The following lines have to be here, otherwise all volumes disappear
if not volume or not area:
triangle_filter = vtk.vtkTriangleFilter()
triangle_filter.SetInputData(polydata)
triangle_filter.Update()
measured_polydata = vtk.vtkMassProperties()
measured_polydata.SetInputConnection(
triangle_filter.GetOutputPort())
measured_polydata.Update()
volume = measured_polydata.GetVolume()
area = measured_polydata.GetSurfaceArea()
surface.volume = volume
surface.area = area
print(">>>>", surface.volume)
else:
surface.volume = volume
surface.area = area
self.last_surface_index = surface.index
Publisher.sendMessage('Load surface actor into viewer', actor=actor)
Publisher.sendMessage('Update surface info in GUI', surface=surface)
return surface.index
def vis_ested_pcd_corners(ind=1):
# pair_ind = 9
pcd_result_file = "output/pcd_seg/" + str(ind).zfill(4) + "_pcd_result.pkl"
csv_file = "pcd/" + str(ind).zfill(4) + ".csv"
full_arr = np.genfromtxt(csv_file, delimiter=",", skip_header=1)
grid_coords = generate_grid_coords()
with open(os.path.abspath(pcd_result_file), "r") as f:
pcd_result_ls = cPickle.load(f)
assert pcd_result_ls is not None
rot1 = pcd_result_ls[0]
t1 = pcd_result_ls[1].reshape(1, 3)
rot2 = pcd_result_ls[2]
t2 = pcd_result_ls[3].reshape(1, 3)
trans_grid_ls = []
for coords in grid_coords:
args = [[coord, rot1, rot2, t1, t2] for coord in coords[:3]]
trans_coords = map(transform_grid, args)
trans_coords.append(coords[3])
trans_grid_ls.append(trans_coords)
ren = vtk.vtkRenderer()
ren.SetBackground(.2, .3, .4)
ren.SetBackground(0.90196079, 0.96078432, 0.59607846)
# ren.SetBackground(1., 1., 1.)
for i in xrange(len(trans_grid_ls)):
tmp_actor = draw_one_grd_vtk(trans_grid_ls[i])
tmp_actor.GetProperty().SetOpacity(0.5)
ren.AddActor(tmp_actor)
show_only_marker = True
if show_only_marker:
marker_full_data_arr = exact_full_marker_data(csv_file,
[pcd_result_ls[-1]])
actor2 = vis_3D_points(marker_full_data_arr, color_style="intens_rg")
else:
actor2 = vis_3D_points(full_arr, color_style="intens_rg")
ren.AddActor(actor2)
transform2 = vtk.vtkTransform()
transform2.Translate(0.0, 0.0, 0.0)
axes2 = vtk.vtkAxesActor()
axes2.SetUserTransform(transform2)
ren.AddActor(axes2)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName(str(i).zfill(4))
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
def get_camera_info(obj, ev):
if iren.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
print "screenshot saved"
style = vtk.vtkInteractorStyleSwitch()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(style)
# style.SetCurrentStyleToTrackballActor()
style.SetCurrentStyleToTrackballCamera()
iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1)
iren.Initialize()
renWin.Render()
renWin.SetWindowName(str(ind).zfill(4))
iren.Start()
def fitToViewport(Actor, Renderer, vp, wc=None, geo=None):
T = vtk.vtkTransform()
## Data range in World Coordinates
if wc is None:
Xrg = list(Actor.GetXRange())
Yrg = list(Actor.GetYRange())
else:
Xrg = [float(wc[0]), float(wc[1])]
Yrg = [float(wc[2]), float(wc[3])]
if Yrg[0] > Yrg[1]:
#Yrg=[Yrg[1],Yrg[0]]
#T.RotateY(180)
Yrg = [Yrg[1], Yrg[0]]
flipY = True
else:
flipY = False
if Xrg[0] > Xrg[1]:
Xrg = [Xrg[1], Xrg[0]]
flipX = True
else:
flipX = False
if geo is not None:
pt = vtk.vtkPoints()
pt.SetNumberOfPoints(1)
Xrg2 = [1.e20, -1.e20]
Yrg2 = [1.e20, -1.e20]
Npts = 50.
for x in numpy.arange(Xrg[0], Xrg[1], (Xrg[1] - Xrg[0]) / Npts):
for y in numpy.arange(Yrg[0], Yrg[1], (Yrg[1] - Yrg[0]) / Npts):
pt.SetPoint(0, x, y, 0)
pts = vtk.vtkPoints()
geo.TransformPoints(pt, pts)
b = pts.GetBounds()
xm, xM, ym, yM = b[:4]
if xm != -numpy.inf:
Xrg2[0] = min(Xrg2[0], xm)
if xM != numpy.inf:
Xrg2[1] = max(Xrg2[1], xM)
if ym != -numpy.inf:
Yrg2[0] = min(Yrg2[0], ym)
if yM != numpy.inf:
Yrg2[1] = max(Yrg2[1], yM)
Xrg = Xrg2
Yrg = Yrg2
Renderer.SetViewport(vp[0], vp[2], vp[1], vp[3])
rw = Renderer.GetRenderWindow()
sc = rw.GetSize()
wRatio = float(sc[0]) / float(sc[1])
dRatio = (Xrg[1] - Xrg[0]) / (Yrg[1] - Yrg[0])
vRatio = float(vp[1] - vp[0]) / float(vp[3] - vp[2])
if wRatio > 1.: #landscape orientated window
yScale = 1.
xScale = vRatio * wRatio / dRatio
else:
xScale = 1.
yScale = dRatio / (vRatio * wRatio)
T.Scale(xScale, yScale, 1.)
Actor.SetUserTransform(T)
mapper = Actor.GetMapper()
planeCollection = mapper.GetClippingPlanes()
# We have to transform the hardware clip planes as well
if (planeCollection is not None):
planeCollection.InitTraversal()
plane = planeCollection.GetNextItem()
while (plane):
origin = plane.GetOrigin()
inOrigin = [origin[0], origin[1], origin[2], 1.0]
outOrigin = [origin[0], origin[1], origin[2], 1.0]
normal = plane.GetNormal()
inNormal = [normal[0], normal[1], normal[2], 0.0]
outNormal = [normal[0], normal[1], normal[2], 0.0]
T.MultiplyPoint(inOrigin, outOrigin)
if (outOrigin[3] != 0.0):
outOrigin[0] /= outOrigin[3]
outOrigin[1] /= outOrigin[3]
outOrigin[2] /= outOrigin[3]
plane.SetOrigin(outOrigin[0], outOrigin[1], outOrigin[2])
# For normal matrix, compute the transpose of inverse
normalTransform = vtk.vtkTransform()
normalTransform.DeepCopy(T)
mat = vtk.vtkMatrix4x4()
normalTransform.GetTranspose(mat)
normalTransform.GetInverse(mat)
normalTransform.SetMatrix(mat)
normalTransform.MultiplyPoint(inNormal, outNormal)
if (outNormal[3] != 0.0):
outNormal[0] /= outNormal[3]
outNormal[1] /= outNormal[3]
outNormal[2] /= outNormal[3]
plane.SetNormal(outNormal[0], outNormal[1], outNormal[2])
plane = planeCollection.GetNextItem()
xc = xScale * float(Xrg[1] + Xrg[0]) / 2.
yc = yScale * float(Yrg[1] + Yrg[0]) / 2.
xd = xScale * float(Xrg[1] - Xrg[0]) / 2.
yd = yScale * float(Yrg[1] - Yrg[0]) / 2.
cam = Renderer.GetActiveCamera()
cam.ParallelProjectionOn()
cam.SetParallelScale(yd)
cd = cam.GetDistance()
cam.SetPosition(xc, yc, cd)
cam.SetFocalPoint(xc, yc, 0.)
if geo is None:
if flipY:
cam.Elevation(180.)
cam.Roll(180.)
pass
if flipX:
cam.Azimuth(180.)
def vis_all_markers(ls=[1]):
import vtk
ren = vtk.vtkRenderer()
# ren.SetBackground(.2, .3, .4)
ren.SetBackground(.5, .6, .7)
for i in ls:
pcd_result_file = "output/pcd_seg/" + str(i).zfill(
4) + "_pcd_result.pkl"
csv_path = "pcd/" + str(i).zfill(4) + ".csv"
with open(os.path.abspath(pcd_result_file), "r") as f:
pcd_result_ls = cPickle.load(f)
assert pcd_result_ls is not None
marker_full_data_arr = exact_full_marker_data(csv_path,
[pcd_result_ls[-1]])
marker_arr = marker_full_data_arr[:, :3]
# transformed_pcd = roate_with_rt(np.array(r_t), marker_arr)
if i % 4 == 0:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:]
]),
color_style="intens")
elif i % 4 == 1:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:]
]),
color_style="autumn")
elif i % 4 == 2:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:]
]),
color_style="cool")
else:
actor2 = vis_3D_points(np.hstack([
marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:]
]),
color_style="intens_rg")
ren.AddActor(actor2)
transform2 = vtk.vtkTransform()
transform2.Translate(0.0, 0.0, 0.0)
axes2 = vtk.vtkAxesActor()
axes2.SetUserTransform(transform2)
ren.AddActor(axes2)
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetBounds((-3, 3, -3, 3, -2, 2))
cubeAxesActor.SetCamera(ren.GetActiveCamera())
cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 0.0, 0.0)
cubeAxesActor.GetLabelTextProperty(0).SetColor(1.0, 0.0, 0.0)
cubeAxesActor.GetTitleTextProperty(1).SetColor(0.0, 1.0, 0.0)
cubeAxesActor.GetLabelTextProperty(1).SetColor(0.0, 1.0, 0.0)
cubeAxesActor.GetTitleTextProperty(2).SetColor(0.0, 0.0, 1.0)
cubeAxesActor.GetLabelTextProperty(2).SetColor(0.0, 0.0, 1.0)
cubeAxesActor.DrawXGridlinesOn()
cubeAxesActor.DrawYGridlinesOn()
cubeAxesActor.DrawZGridlinesOn()
# if vtk.VTK_MAJOR_VERSION > 5:
# cubeAxesActor.SetGridLineLocation(vtk.VTK_GRID_LINES_FURTHEST)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
# cubeAxesActor.GetProperty().SetColor(0, 255, 0)
cubeAxesActor.GetXAxesLinesProperty().SetColor(0, 255, 0)
cubeAxesActor.GetYAxesLinesProperty().SetColor(0, 255, 0)
cubeAxesActor.GetZAxesLinesProperty().SetColor(0, 255, 0)
ren.AddActor(cubeAxesActor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleSwitch()
iren.SetInteractorStyle(style)
style.SetCurrentStyleToTrackballCamera()
def get_camera_info(obj, ev):
if iren.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renWin)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
writer.SetInputData(w2if.GetOutput())
writer.Write()
print "screenshot saved"
# save to pdf
if iren.GetKeyCode() == "s":
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(renWin)
exp.SetFilePrefix("screenpdf")
exp.SetFileFormat(2)
exp.SetCompress(False)
exp.SetLandscape(False)
exp.SetSortToBSP()
# exp.SetSortToSimple() # less expensive sort algorithm
exp.DrawBackgroundOn()
exp.SetWrite3DPropsAsRasterImage(False)
iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1)
iren.SetRenderWindow(renWin)
renWin.Render()
# ren.SetActiveCamera(camera)
iren.Initialize()
iren.Start()
def TestSection_ImportExportSegment(self):
# Import/export, both one label and all labels
logging.info('Test section: Import/export segment')
# Export single segment to model node
bodyModelNode = slicer.vtkMRMLModelNode()
bodyModelNode.SetName('BodyModel')
slicer.mrmlScene.AddNode(bodyModelNode)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(
self.bodySegmentName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(
bodySegment, bodyModelNode)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNode.GetPolyData())
#TODO: Number of points increased to 1677 due to end-capping, need to investigate!
#self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302)
#TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate
# self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588)
#self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580)
# Export single segment to volume node
bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNode.SetName('BodyLabelmap')
slicer.mrmlScene.AddNode(bodyLabelmapNode)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(
bodySegment, bodyLabelmapNode)
self.assertTrue(result)
bodyImageData = bodyLabelmapNode.GetImageData()
self.assertIsNotNone(bodyImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(bodyImageData)
imageStat.Update()
self.assertEqual(imageStat.GetVoxelCount(), 792)
self.assertEqual(imageStat.GetMin()[0], 0)
self.assertEqual(imageStat.GetMax()[0], 1)
# Export multiple segments to volume node
allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap')
slicer.mrmlScene.AddNode(allSegmentsLabelmapNode)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode(
self.inputSegmentationNode, allSegmentsLabelmapNode)
self.assertTrue(result)
allSegmentsImageData = allSegmentsLabelmapNode.GetImageData()
self.assertIsNotNone(allSegmentsImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(allSegmentsImageData)
imageStat.SetComponentExtent(0, 5, 0, 0, 0, 0)
imageStat.SetComponentOrigin(0, 0, 0)
imageStat.SetComponentSpacing(1, 1, 1)
imageStat.Update()
imageStatResult = imageStat.GetOutput()
for i in range(4):
logging.info("Volume {0}: {1}".format(
i, imageStatResult.GetScalarComponentAsDouble(i, 0, 0, 0)))
self.assertEqual(imageStat.GetVoxelCount(), 127109360)
self.assertEqual(
imageStatResult.GetScalarComponentAsDouble(0, 0, 0, 0), 78967249)
self.assertEqual(
imageStatResult.GetScalarComponentAsDouble(1, 0, 0, 0), 39705288)
self.assertEqual(
imageStatResult.GetScalarComponentAsDouble(2, 0, 0, 0), 890883)
self.assertEqual(
imageStatResult.GetScalarComponentAsDouble(3, 0, 0, 0), 7545940)
# Import model to segment
modelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode', 'ModelImport')
modelImportSegmentationNode.GetSegmentation(
).SetMasterRepresentationName(self.closedSurfaceReprName)
modelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(
bodyModelNode)
modelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegment)
self.assertIsNotNone(
modelSegment.GetRepresentation(self.closedSurfaceReprName))
# Import multi-label labelmap to segmentation
multiLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode', 'MultiLabelImport')
multiLabelImportSegmentationNode.GetSegmentation(
).SetMasterRepresentationName(self.binaryLabelmapReprName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(
allSegmentsLabelmapNode, multiLabelImportSegmentationNode)
self.assertTrue(result)
self.assertEqual(
multiLabelImportSegmentationNode.GetSegmentation().
GetNumberOfSegments(), 3)
# Import labelmap into single segment
singleLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode', 'SingleLabelImport')
singleLabelImportSegmentationNode.GetSegmentation(
).SetMasterRepresentationName(self.binaryLabelmapReprName)
# Should not import multi-label labelmap to segment
nullSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(
allSegmentsLabelmapNode)
self.assertIsNone(nullSegment)
logging.info(
'(This error message is a result of testing an impossible scenario, it is supposed to appear)'
)
# Make labelmap single-label and import again
threshold = vtk.vtkImageThreshold()
threshold.SetInValue(0)
threshold.SetOutValue(1)
threshold.ReplaceInOn()
threshold.ThresholdByLower(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
if vtk.VTK_MAJOR_VERSION <= 5:
threshold.SetInput(allSegmentsLabelmapNode.GetImageData())
else:
threshold.SetInputData(allSegmentsLabelmapNode.GetImageData())
threshold.Update()
allSegmentsLabelmapNode.GetImageData().ShallowCopy(
threshold.GetOutput())
labelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(
allSegmentsLabelmapNode)
labelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(labelSegment)
self.assertIsNotNone(
labelSegment.GetRepresentation(self.binaryLabelmapReprName))
# Import/export with transforms
logging.info('Test subsection: Import/export with transforms')
# Create transform node that will be used to transform the tested nodes
bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(bodyModelTransformNode)
bodyModelTransform = vtk.vtkTransform()
bodyModelTransform.Translate(1000.0, 0.0, 0.0)
bodyModelTransformNode.ApplyTransformMatrix(
bodyModelTransform.GetMatrix())
# Set transform as parent to input segmentation node
self.inputSegmentationNode.SetAndObserveTransformNodeID(
bodyModelTransformNode.GetID())
# Export single segment to model node from transformed segmentation
bodyModelNodeTransformed = slicer.vtkMRMLModelNode()
bodyModelNodeTransformed.SetName('BodyModelTransformed')
slicer.mrmlScene.AddNode(bodyModelNodeTransformed)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(
self.bodySegmentName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(
bodySegment, bodyModelNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode())
# Export single segment to volume node from transformed segmentation
bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed')
slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(
bodySegment, bodyLabelmapNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(
bodyLabelmapNodeTransformed.GetParentTransformNode())
# Create transform node that will be used to transform the tested nodes
modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode(
)
slicer.mrmlScene.AddNode(
modelTransformedImportSegmentationTransformNode)
modelTransformedImportSegmentationTransform = vtk.vtkTransform()
modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0)
modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix(
modelTransformedImportSegmentationTransform.GetMatrix())
# Import transformed model to segment in transformed segmentation
modelTransformedImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode', 'ModelImportTransformed')
modelTransformedImportSegmentationNode.GetSegmentation(
).SetMasterRepresentationName(self.closedSurfaceReprName)
modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID(
modelTransformedImportSegmentationTransformNode.GetID())
modelSegmentTranformed = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(
bodyModelNodeTransformed, modelTransformedImportSegmentationNode)
modelSegmentTranformed.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegmentTranformed)
modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation(
self.closedSurfaceReprName)
self.assertIsNotNone(modelSegmentTransformedPolyData)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]),
1332)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]),
1675)
# Clean up temporary nodes
slicer.mrmlScene.RemoveNode(bodyModelNode)
slicer.mrmlScene.RemoveNode(bodyLabelmapNode)
slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode)
slicer.mrmlScene.RemoveNode(modelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(bodyModelTransformNode)
slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed)
slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed)
slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def expand_cyclic_modal_stress(self, result, result_r, hindex, phase, as_complex,
full_rotor, scale=True):
""" Combines repeated results from ANSYS """
if as_complex or full_rotor:
result_combined = result + result_r*1j
if phase:
result_combined *= 1*np.cos(phase) - 1j*np.sin(phase)
else: # convert to real
result_combined = result*np.cos(phase) - result_r*np.sin(phase)
# just return single sector
if not full_rotor:
return result_combined
# Generate full rotor solution
result_expanded = np.empty((self.n_sector, result.shape[0], result.shape[1]),
np.complex128)
result_expanded[:] = result_combined
# scale
# if scale:
# if hindex == 0 or hindex == self.n_sector/2:
# result_expanded /= self.n_sector**0.5
# else:
# result_expanded /= (self.n_sector/2)**0.5
f_arr = np.zeros(self.n_sector)
f_arr[hindex] = 1
jang = np.fft.ifft(f_arr)[:self.n_sector]*self.n_sector
cjang = jang * (np.cos(phase) - np.sin(phase) * 1j)
full_result = np.real(result_expanded*cjang.reshape(-1, 1, 1))
# # rotate cyclic result inplace
# angles = np.linspace(0, 2*np.pi, self.n_sector + 1)[:-1] + phase
# for i, angle in enumerate(angles):
# isnan = _binary_reader.tensor_rotate_z(result_expanded[i], angle)
# result_expanded[i, isnan] = np.nan
cs_cord = self.resultheader['csCord']
if cs_cord > 1:
matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True)
i_matrix.Invert()
else:
matrix = vtk.vtkMatrix4x4()
i_matrix = vtk.vtkMatrix4x4()
shp = (self.n_sector, result.shape[0], result.shape[1])
full_result = np.empty(shp)
full_result[:] = result
rang = 360.0 / self.n_sector
for i in range(self.n_sector):
# transform to standard position, rotate about Z axis,
# transform back
transform = vtk.vtkTransform()
transform.RotateZ(rang*i)
transform.Update()
rot_matrix = transform.GetMatrix()
if cs_cord > 1:
temp_matrix = vtk.vtkMatrix4x4()
rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix)
rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix)
trans = pv.trans_from_matrix(rot_matrix)
_binary_reader.tensor_arbitrary(full_result[i], trans)
return full_result
def SliceOrder():
#
# These transformations permute medical image data to maintain proper orientation
# regardless of the acquisition order. After applying these transforms with
# vtkTransformFilter, a view up of 0,-1,0 will result in the body part
# facing the viewer.
# NOTE: some transformations have a -1 scale factor for one of the components.
# To ensure proper polygon orientation and normal direction, you must
# apply the vtkPolyDataNormals filter.
#
# Naming:
# si - superior to inferior (top to bottom)
# is - inferior to superior (bottom to top)
# ap - anterior to posterior (front to back)
# pa - posterior to anterior (back to front)
# lr - left to right
# rl - right to left
#
sliceOrder = dict()
siMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]
si = vtk.vtkTransform()
si.SetMatrix(siMatrix)
sliceOrder["si"] = si
isMatrix = [1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 1]
i_s = vtk.vtkTransform() # 'is' is a keyword in Python, changed to 'i_s'
i_s.SetMatrix(isMatrix)
sliceOrder["is"] = i_s
ap = vtk.vtkTransform()
ap.Scale(1, -1, 1)
sliceOrder["ap"] = ap
pa = vtk.vtkTransform()
pa.Scale(1, -1, -1)
sliceOrder["pa"] = pa
lrMatrix = [0, 0, -1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]
lr = vtk.vtkTransform()
lr.SetMatrix(lrMatrix)
sliceOrder["lr"] = lr
rlMatrix = [0, 0, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]
rl = vtk.vtkTransform()
rl.SetMatrix(rlMatrix)
sliceOrder["rl"] = rl
#
# The previous transforms assume radiological views of the slices (viewed from the feet). other
# modalities such as physical sectioning may view from the head. these transforms modify the original
# with a 180 rotation about y
#
hfMatrix = [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]
hf = vtk.vtkTransform()
hf.SetMatrix(hfMatrix)
sliceOrder["hf"] = hf
hfsi = vtk.vtkTransform()
hfsi.Concatenate(hf.GetMatrix())
hfsi.Concatenate(si.GetMatrix())
sliceOrder["hfsi"] = hfsi
hfis = vtk.vtkTransform()
hfis.Concatenate(hf.GetMatrix())
hfis.Concatenate(i_s.GetMatrix())
sliceOrder["hfis"] = hfis
hfap = vtk.vtkTransform()
hfap.Concatenate(hf.GetMatrix())
hfap.Concatenate(ap.GetMatrix())
sliceOrder["hfap"] = hfap
hfpa = vtk.vtkTransform()
hfpa.Concatenate(hf.GetMatrix())
hfpa.Concatenate(pa.GetMatrix())
sliceOrder["hfpa"] = hfpa
hflr = vtk.vtkTransform()
hflr.Concatenate(hf.GetMatrix())
hflr.Concatenate(lr.GetMatrix())
sliceOrder[""] = hflr
hfrl = vtk.vtkTransform()
hfrl.Concatenate(hf.GetMatrix())
hfrl.Concatenate(rl.GetMatrix())
sliceOrder["hfrl"] = hfrl
return sliceOrder
