def wrapOpImp(self):
self.preMashCommand.data = self.mashData;
self.mashData = self.preMashCommand.execute();
self.transform_one.data = self.data;
import vtkMeasure;
data_one = self.transform_one.perform();
measure_one = vtkMeasure.measure_factory(data_one);
self.transform_two.data = self.mashData;
data_two = self.transform_two.perform()
measure_two = vtkMeasure.measure_factory(data_two);
poly2Vops = Poly2ImageOp();
poly2Vops.data = data_one;
img_data_one = poly2Vops.perform();
resoulation_one = poly2Vops.resoulation;
poly2Vops.data = data_two;
img_data_two = poly2Vops.perform();
resoulation_two = poly2Vops.resoulation;
resoulation = [min(resoulation_one[0],resoulation_two[0]),min(resoulation_one[1],resoulation_two[1]),min(resoulation_one[2],resoulation_two[2])];
self.transform_one.data = data_one;
self.transform_two.data = data_two;
implicitV_One = vtk.vtkImplicitVolume();
implicitV_One.SetVolume(img_data_one);
transform_one = self.transform_one.getLinkedTransform();
implicitV_One.SetTransform(transform_one.GetInverse());
implicitV_One.SetOutValue(IMAGEOUT);
implicitV_Two = vtk.vtkImplicitVolume();
implicitV_Two.SetVolume(img_data_two);
transform_two = self.transform_two.getLinkedTransform();
implicitV_Two.SetTransform(transform_two.GetInverse());
implicitV_Two.SetOutValue(IMAGEOUT);
boolOp = vtk.vtkImplicitBoolean();
boolOp.AddFunction(implicitV_One);
boolOp.AddFunction(implicitV_Two);
boolOp.SetOperationTypeToUnion();
#boolOp.SetOperationTypeToDifference();
#boolOp.SetOperationTypeToIntersection();
implicit2Poly = Implicit2Poly();
import vtk2Box;
xMin = min(measure_one.xSize[0],measure_two.xSize[0]);
xMax = max(measure_one.xSize[1],measure_two.xSize[1]);
yMin = min(measure_one.ySize[0],measure_two.ySize[0]);
yMax = max(measure_one.ySize[1],measure_two.ySize[1]);
zMin = min(measure_one.zSize[0],measure_two.zSize[0]);
zMax = max(measure_one.zSize[1],measure_two.zSize[1]);
implicit2Poly.bbox = vtk2Box.BBox(xMin,xMax,yMin,yMax,zMin,zMax);
implicit2Poly.resoulation = resoulation;
implicit2Poly.data = boolOp;
result = implicit2Poly.perform();
return result;
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# initialise any mixins we might have
NoConfigModuleMixin.__init__(self)
self._distance = vtk.vtkImageEuclideanDistance()
# this seems to yield more accurate results in this case
# it would probably be better to calculate only 2d distance fields
self._distance.ConsiderAnisotropyOff()
self._xEndPoints = []
self._noFlipXes = []
self._pf1 = vtk.vtkProgrammableFilter() # yeah
self._pf1.SetInput(self._distance.GetOutput())
self._pf1.SetExecuteMethod(self.pf1Execute)
self._pf2 = vtk.vtkProgrammableFilter()
self._pf2.SetInput(self._pf1.GetOutput())
self._pf2.SetExecuteMethod(self.pf2Execute)
self._mc = vtk.vtkMarchingCubes()
self._mc.SetInput(self._pf1.GetOutput())
self._mc.SetValue(0, 0.1)
self._iv = vtk.vtkImplicitVolume()
self._iv.SetVolume(self._pf2.GetOutput())
self._cpd = vtk.vtkClipPolyData()
self._cpd.SetClipFunction(self._iv)
self._cpd.SetInput(self._mc.GetOutput())
#self._cpd.InsideOutOn()
module_utils.setup_vtk_object_progress(
self, self._distance, 'Calculating distance field...')
module_utils.setup_vtk_object_progress(self, self._pf1,
'Signing distance field...')
module_utils.setup_vtk_object_progress(self, self._pf2,
'Creating implicit volume...')
module_utils.setup_vtk_object_progress(self, self._mc,
'Extracting isosurface...')
module_utils.setup_vtk_object_progress(self, self._cpd,
'Clipping isosurface...')
self._iObj = self._distance
self._oObj = self._cpd
#self._oObj = self._pf2
self._viewFrame = self._createViewFrame({
'distance': self._distance,
'pf1': self._pf1,
'pf2': self._pf2,
'mc': self._mc,
'cpd': self._cpd
})
def onGradientInNewVolBtnClicked(self):
# Result is not right!
volumeNode = slicer.util.getNode("MRHead")
ijkToRas = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(ijkToRas)
imageData = volumeNode.GetImageData()
extent = imageData.GetExtent()
imageSize = imageData.GetDimensions()
imageSpacing = imageData.GetSpacing()
voxelType = vtk.VTK_FLOAT
# Create empty image volume
imageData_2 = vtk.vtkImageData()
imageData_2.SetDimensions(imageSize[0] / 2, imageSize[1] / 2, imageSize[2] / 2)
imageData_2.SetSpacing(imageSpacing)
imageData_2.AllocateScalars(voxelType, 0)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData_2)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
volumeNode_2 = slicer.vtkMRMLScalarVolumeNode()
volumeNode_2.SetSpacing(imageSpacing)
volumeNode_2.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
scene = slicer.mrmlScene
scene.AddNode(volumeNode_2)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
scene.AddNode(displayNode)
colorNode = slicer.util.getNode("Grey")
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
volumeNode_2.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode_2.CreateDefaultStorageNode()
# npData = slicer.util.array('MRHead')
impVol = vtk.vtkImplicitVolume()
impVol.SetVolume(imageData)
for k in xrange(extent[4], extent[5] / 2 + 1):
for j in xrange(extent[2], extent[3] / 2 + 1):
for i in xrange(extent[0], extent[1] / 2 + 1):
g = impVol.FunctionGradient(i, j, k)
gradient = math.sqrt(g[0] ** 2 + g[1] ** 2 + g[2] ** 2)
imageData_2.SetScalarComponentFromFloat(i, j, k, 0, gradient)
imageData_2.Modified()
def onGradientBtnClicked(self):
volumeNode = slicer.util.getNode("MRHead")
ijkToRas = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(ijkToRas)
imageData = volumeNode.GetImageData()
extent = imageData.GetExtent()
# npData = slicer.util.array('MRHead')
impVol = vtk.vtkImplicitVolume()
impVol.SetVolume(imageData)
for k in xrange(extent[4], extent[5] / 2 + 1):
for j in xrange(extent[2], extent[3] / 2 + 1):
for i in xrange(extent[0], extent[1] / 2 + 1):
g = impVol.FunctionGradient(i, j, k)
gradient = math.sqrt(g[0] ** 2 + g[1] ** 2 + g[2] ** 2)
imageData.SetScalarComponentFromFloat(i, j, k, 0, gradient)
imageData.Modified()
def __init__(self):
ActorFactory.ActorFactory.__init__(self)
# whether to display the volume
self._ShowVolume = 1
self._StatusChange = 0
# create a clipping cube to go with the volume
self._ClippingCube = ClippingCubeFactory.ClippingCubeFactory()
self.AddChild(self._ClippingCube)
self._CubeClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CubeClippingPlanes.AddItem(vtk.vtkPlane())
# for if we clip in with OrthoPlanes
self._OrthoPlanes = None
self._ShowOrthoPlanes = 1
self._OrthoPlanesLookupTables = {}
self._OrthoPickThreshold = 0.0025
# corner clipping planes, in pairs with opposite normals
self._CornerClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CornerClippingPlanes.AddItem(vtk.vtkPlane())
# clipping planes for the volume, sorted for the
# three chunks that will make up the final volume
self._ClippingPlanes = [
vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection()
]
for i in range(3):
planes = self._ClippingPlanes[i]
cplanes = self._CornerClippingPlanes
bplanes = self._CubeClippingPlanes
if i == 0:
planes.AddItem(cplanes.GetItemAsObject(0))
planes.AddItem(bplanes.GetItemAsObject(1))
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(0))
planes.AddItem(cplanes.GetItemAsObject(1))
if i == 1:
planes.AddItem(cplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(cplanes.GetItemAsObject(3))
if i == 2:
planes.AddItem(cplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
self._Input = None
# generate the pipeline
self._ImagePrefilter = vtk.vtkImageShrink3D()
self._ImageReslice = vtk.vtkImageReslice()
self._ImageReslice.SetInterpolationModeToLinear()
self._ImageMapToColors = vtk.vtkImageMapToColors()
self._ImageMapToColors.SetOutputFormatToRGBA()
self._ImageToStructuredPoints = vtk.vtkImageToStructuredPoints()
self._ImageClipsXY = []
self._PlanesXY = []
self._ActorsXY = []
self._PropertyXY = vtk.vtkProperty()
self._PropertyXY.SetDiffuse(0)
self._PropertyXY.SetAmbient(1)
self._ImageClipsYZ = []
self._PlanesYZ = []
self._ActorsYZ = []
self._PropertyYZ = vtk.vtkProperty()
self._PropertyYZ.SetDiffuse(0)
self._PropertyYZ.SetAmbient(1)
self._ImageClipsZX = []
self._PlanesZX = []
self._ActorsZX = []
self._PropertyZX = vtk.vtkProperty()
self._PropertyZX.SetDiffuse(0)
self._PropertyZX.SetAmbient(1)
# a list of the renderer info
self._RendererCurrentIndex = {}
self._RendererActorList = {}
self._RendererObserverList = {}
# a transform to apply to the image
self._ImageTransform = None
self._TransformToGrid = vtk.vtkTransformToGrid()
# the alpha pick threshold for the volume
self._PickThreshold = 0.25
# the implicit volume for finding the gradient
self._ImplicitVolume = vtk.vtkImplicitVolume()
# the extent of the texture maps
self._VolumeResolution = (64, 64, 64)
# the bounds of the volume
self._VolumeBounds = None
(range_y[1] - range_y[0]) / (dim_y - 1.0),
(range_z[1] - range_z[0]) / (dim_z - 1.0)]
# Convert vtkFloatArray to vtkImageData
vtk_image_data = vtk.vtkImageData()
vtk_image_data.SetDimensions(quadric_2.shape)
vtk_image_data.SetSpacing([0.1] * 3) # How to set a correct spacing value??
vtk_image_data.GetPointData().SetScalars(vtk_array)
vtk_image_data.SetOrigin(-1, -1, -1)
vtk_image_data.SetSpacing(spacing)
dims = vtk_image_data.GetDimensions()
bounds = vtk_image_data.GetBounds()
implicit_volume = vtk.vtkImplicitVolume()
implicit_volume.SetVolume(vtk_image_data)
sample_2 = vtk.vtkSampleFunction()
sample_2.SetImplicitFunction(implicit_volume)
sample_2.SetModelBounds(bounds)
sample_2.ComputeNormalsOff()
contour_2 = vtk.vtkContourFilter()
contour_2.SetInputConnection(sample_2.GetOutputPort())
contour_2.SetValue(0, contour_value)
# ===========================================================================
# Rendering
renderer_1 = vtk.vtkRenderer() # for vtkQuadric
renderer_2 = vtk.vtkRenderer() # for meshgrid
def __init__(self):
ActorFactory.ActorFactory.__init__(self)
# whether to display the volume
self._ShowVolume = 1
self._StatusChange = 0
# create a clipping cube to go with the volume
self._ClippingCube = ClippingCubeFactory.ClippingCubeFactory()
self.AddChild(self._ClippingCube)
self._CubeClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CubeClippingPlanes.AddItem(vtk.vtkPlane())
# for if we clip in with OrthoPlanes
self._OrthoPlanes = None
self._ShowOrthoPlanes = 1
self._OrthoPlanesLookupTables = {}
self._OrthoPickThreshold = 0.0025
# corner clipping planes, in pairs with opposite normals
self._CornerClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CornerClippingPlanes.AddItem(vtk.vtkPlane())
# clipping planes for the volume, sorted for the
# three chunks that will make up the final volume
self._ClippingPlanes = [vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection()]
for i in range(3):
planes = self._ClippingPlanes[i]
cplanes = self._CornerClippingPlanes
bplanes = self._CubeClippingPlanes
if i == 0:
planes.AddItem(cplanes.GetItemAsObject(0))
planes.AddItem(bplanes.GetItemAsObject(1))
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(0))
planes.AddItem(cplanes.GetItemAsObject(1))
if i == 1:
planes.AddItem(cplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(cplanes.GetItemAsObject(3))
if i == 2:
planes.AddItem(cplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
self._Input = None
# generate the pipeline
self._ImagePrefilter = vtk.vtkImageShrink3D()
self._ImageReslice = vtk.vtkImageReslice()
self._ImageReslice.SetInterpolationModeToLinear()
self._ImageMapToColors = vtk.vtkImageMapToColors()
self._ImageMapToColors.SetOutputFormatToRGBA()
self._ImageToStructuredPoints = vtk.vtkImageToStructuredPoints()
self._ImageClipsXY = []
self._PlanesXY = []
self._ActorsXY = []
self._PropertyXY = vtk.vtkProperty()
self._PropertyXY.SetDiffuse(0)
self._PropertyXY.SetAmbient(1)
self._ImageClipsYZ = []
self._PlanesYZ = []
self._ActorsYZ = []
self._PropertyYZ = vtk.vtkProperty()
self._PropertyYZ.SetDiffuse(0)
self._PropertyYZ.SetAmbient(1)
self._ImageClipsZX = []
self._PlanesZX = []
self._ActorsZX = []
self._PropertyZX = vtk.vtkProperty()
self._PropertyZX.SetDiffuse(0)
self._PropertyZX.SetAmbient(1)
# a list of the renderer info
self._RendererCurrentIndex = {}
self._RendererActorList = {}
self._RendererObserverList = {}
# a transform to apply to the image
self._ImageTransform = None
self._TransformToGrid = vtk.vtkTransformToGrid()
# the alpha pick threshold for the volume
self._PickThreshold = 0.25
# the implicit volume for finding the gradient
self._ImplicitVolume = vtk.vtkImplicitVolume()
# the extent of the texture maps
self._VolumeResolution = (64, 64, 64)
# the bounds of the volume
self._VolumeBounds = None
def getImplicitVolume(image):
implicitVolume = vtk.vtkImplicitVolume()
implicitVolume.SetVolume(image)
implicitVolume.SetOutValue(-1000)
implicitVolume.SetOutGradient(0,0,0)
return implicitVolume
def __init__(self, module_manager):
# initialise our base class
ModuleBase.__init__(self, module_manager)
# initialise any mixins we might have
NoConfigModuleMixin.__init__(self)
self._distance = vtk.vtkImageEuclideanDistance()
# this seems to yield more accurate results in this case
# it would probably be better to calculate only 2d distance fields
self._distance.ConsiderAnisotropyOff()
self._xEndPoints = []
self._noFlipXes = []
self._pf1 = vtk.vtkProgrammableFilter() # yeah
self._pf1.SetInput(self._distance.GetOutput())
self._pf1.SetExecuteMethod(self.pf1Execute)
self._pf2 = vtk.vtkProgrammableFilter()
self._pf2.SetInput(self._pf1.GetOutput())
self._pf2.SetExecuteMethod(self.pf2Execute)
self._mc = vtk.vtkMarchingCubes()
self._mc.SetInput(self._pf1.GetOutput())
self._mc.SetValue(0,0.1)
self._iv = vtk.vtkImplicitVolume()
self._iv.SetVolume(self._pf2.GetOutput())
self._cpd = vtk.vtkClipPolyData()
self._cpd.SetClipFunction(self._iv)
self._cpd.SetInput(self._mc.GetOutput())
#self._cpd.InsideOutOn()
module_utils.setup_vtk_object_progress(self, self._distance,
'Calculating distance field...')
module_utils.setup_vtk_object_progress(self, self._pf1,
'Signing distance field...')
module_utils.setup_vtk_object_progress(self, self._pf2,
'Creating implicit volume...')
module_utils.setup_vtk_object_progress(self, self._mc,
'Extracting isosurface...')
module_utils.setup_vtk_object_progress(self, self._cpd,
'Clipping isosurface...')
self._iObj = self._distance
self._oObj = self._cpd
#self._oObj = self._pf2
self._viewFrame = self._createViewFrame({'distance' :
self._distance,
'pf1' :
self._pf1,
'pf2' :
self._pf2,
'mc' :
self._mc,
'cpd' :
self._cpd})
def __init__(self):
ActorFactory.ActorFactory.__init__(self)
self._LookupTable = None # lookup table is currently not used
self._ColorTransferFunction = None
self._OpacityTransferFunction = None
self._RendererObserverList = {}
# create a clipping cube to go with the volume
self._ClippingCube = ClippingCubeFactory.ClippingCubeFactory()
self.AddChild(self._ClippingCube)
self._CubeClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CubeClippingPlanes.AddItem(vtk.vtkPlane())
# corner clipping planes, in pairs with opposite normals
self._CornerClippingPlanes = vtk.vtkPlaneCollection()
for i in range(6):
self._CornerClippingPlanes.AddItem(vtk.vtkPlane())
# clipping planes for the volume, sorted for the
# three chunks that will make up the final volume
# (these are currently unused)
self._ClippingPlanes = [vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection(),
vtk.vtkPlaneCollection()]
for i in range(3):
planes = self._ClippingPlanes[i]
cplanes = self._CornerClippingPlanes
bplanes = self._CubeClippingPlanes
if i == 0:
planes.AddItem(cplanes.GetItemAsObject(0))
planes.AddItem(bplanes.GetItemAsObject(1))
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(0))
planes.AddItem(cplanes.GetItemAsObject(1))
if i == 1:
planes.AddItem(cplanes.GetItemAsObject(2))
planes.AddItem(bplanes.GetItemAsObject(3))
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(2))
planes.AddItem(cplanes.GetItemAsObject(3))
if i == 2:
planes.AddItem(cplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
else:
planes.AddItem(bplanes.GetItemAsObject(4))
planes.AddItem(bplanes.GetItemAsObject(5))
# generate the pipeline pieces
self._Input = None
# transform the full-resolution volume
self._RayCastReslice = vtk.vtkImageReslice()
self._RayCastReslice.SetInterpolationModeToLinear()
# subsample the volume for low-res rendering
self._ImagePrefilter1 = vtk.vtkImageShrink3D()
self._ImagePrefilter2 = vtk.vtkImageShrink3D()
# transform the subsampled volume
self._ImageReslice1 = vtk.vtkImageReslice()
self._ImageReslice1.SetInterpolationModeToLinear()
self._ImageReslice2 = vtk.vtkImageReslice()
self._ImageReslice2.SetInterpolationModeToLinear()
# convert to RGBA for rendering (unused)
self._ImageMapToColors = vtk.vtkImageMapToColors()
self._ImageMapToColors.SetOutputFormatToRGBA()
# strictly for VTK 3.2 compatibility
self._ImageToStructuredPoints = vtk.vtkImageToStructuredPoints()
# a transform to apply to the image
self._ImageTransform = None
self._TransformToGrid = vtk.vtkTransformToGrid()
# the opacity pick threshold for the volume
self._PickThreshold = 0.99
# the implicit volume for finding the gradient
self._ImplicitVolume = vtk.vtkImplicitVolume()
# the texture dimensions (later this will be set automatically
# to provide the desired interactive rendering time)
self._TextureSize = 128
# the bounds of the volume
self._VolumeBounds = None
# vtkVolume specific stuff
self._VolumeProperty = vtk.vtkVolumeProperty()
self._VolumeProperty.SetInterpolationTypeToLinear()
rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction()
self._VolumeRayCastMapper = vtk.vtkVolumeRayCastMapper()
self._VolumeRayCastMapper.SetVolumeRayCastFunction(rayCastFunction)
self._VolumeRayCastMapper.SetClippingPlanes(
self._ClippingCube.GetClippingPlanes())
try: # vtk 3.2 does not contain this function call:
self._VolumeRayCastMapper.AutoAdjustSampleDistancesOff()
except:
pass
self._VolumeTextureMapper1 = vtk.vtkVolumeTextureMapper2D()
self._VolumeTextureMapper1.SetTargetTextureSize(old_div(self._TextureSize, 4),
old_div(self._TextureSize, 4))
self._VolumeTextureMapper1.SetMaximumNumberOfPlanes(
old_div(self._TextureSize, 2))
self._VolumeTextureMapper1.SetClippingPlanes(
self._ClippingCube.GetClippingPlanes())
try: # vtk 3.2 does not contain this function call:
# set to the amount of available texture memory (24MB is a good
# start)
self._VolumeTextureMapper1.SetMaximumStorageSize(24 * 1024 * 1024)
except:
pass
self._VolumeTextureMapper2 = vtk.vtkVolumeTextureMapper2D()
self._VolumeTextureMapper2.SetTargetTextureSize(self._TextureSize,
self._TextureSize)
self._VolumeTextureMapper2.SetMaximumNumberOfPlanes(self._TextureSize)
self._VolumeTextureMapper2.SetClippingPlanes(
self._ClippingCube.GetClippingPlanes())
try: # vtk 3.2 does not contain this function call:
# set to the amount of available texture memory (24MB is a good
# start)
self._VolumeTextureMapper2.SetMaximumStorageSize(24 * 1024 * 1024)
except:
pass
# set two levels of detail: texture and ray-casting
self._Volume = vtk.vtkLODProp3D()
self._Volume.PickableOff()
idT1 = self._Volume.AddLOD(self._VolumeTextureMapper1,
self._VolumeProperty,
0.02)
idT2 = self._Volume.AddLOD(self._VolumeTextureMapper2,
self._VolumeProperty,
0.1)
# remember these LOD id numbers
self._lod = [idT1, idT2]
# idRC = self._Volume.AddLOD(self._VolumeRayCastMapper,
# self._VolumeProperty,
# 2.0)
self._Volume.SetLODLevel(idT1, 2.0)
self._Volume.SetLODLevel(idT2, 1.0)