def axonComparison(axons, N):
axonsToRender = []
for i in range(N):
axon = axons.pop(random.randrange(len(axons)))
axonsToRender.append(axon)
bins = main.BINS
data_matrix = numpy.zeros([500, 500, 500], dtype=numpy.uint16)
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, 500, 0, 500, 0, 500)
dataImporter.SetWholeExtent(0, 500, 0, 500, 0, 500)
volumeProperty = vtk.vtkVolumeProperty()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.SetBackground(1, 1, 1)
renderWin.SetSize(400, 400)
for axon in axonsToRender:
renderer = Utils.renderSingleAxon(axon, renderer, [random.random(), random.random(), random.random()])
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def setVolumeVisualization(self, volumeVisualization):
"""
Updates the volume property. It actually removes the volume,
creates a new volume and sets the updated volume property and
then adds the new volume to the renderer.
Just updating the vtkVolumeProperty gives artifacts and seems
to not work correctly.
:type volumeVisualization: volumeVisualization
"""
self.volumeVisualization = volumeVisualization
if self.imageData is None or self.volumeVisualization is None:
if self.volume is not None:
self.renderer.RemoveViewProp(self.volume)
self.volume = None
return
if self.volume is None:
self.volume = vtkVolume()
self.renderer.AddViewProp(self.volume)
self.volumeVisualization.setMapper(self.mapper)
self.mapper.SetShaderType(self.volumeVisualization.shaderType())
if self.volume.GetProperty() != self.volumeVisualization.volProp:
self.volume.SetProperty(self.volumeVisualization.volProp)
if self.volume.GetMapper() != self.mapper:
self.volume.SetMapper(self.mapper)
self.render()
def create_volume_rendering(self):
opacityfunction=vtk.vtkPiecewiseFunction()
opacityfunction.AddPoint(0,0.0)
opacityfunction.AddPoint(0.1,0.01)
opacityfunction.AddPoint(1,0.02)
opacityfunction.AddPoint(1.5,0.03)
volproperty=vtk.vtkVolumeProperty()
volproperty.SetColor(self.arrowColor)
volproperty.SetScalarOpacity(opacityfunction)
volproperty.ShadeOn()
volproperty.SetInterpolationTypeToLinear()
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.vol_reader.GetOutputPort())
volumeMapper.SetSampleDistance(0.01)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volproperty)
return volume
def initUI(self):
self.frame = QtGui.QFrame()
self.widgetLayout = QtGui.QVBoxLayout()
self.setLayout(self.widgetLayout)
self.widgetLayout.addWidget(self.frame)
self.frameLayout = QtGui.QVBoxLayout()
self.frame.setLayout(self.frameLayout)
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.frameLayout.addWidget(self.vtkWidget)
self.sliceNumber = QtGui.QLineEdit("50")
self.sliceConfirm = QtGui.QPushButton("confirm")
self.sliceConfirm.clicked.connect(self.showLayer)
self.sliceButtonLayout = QtGui.QHBoxLayout()
self.sliceButtonLayout.addWidget(self.sliceNumber)
self.sliceButtonLayout.addWidget(self.sliceConfirm)
self.frameLayout.addLayout(self.sliceButtonLayout)
self.volume = vtk.vtkVolume()
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.show()
self.iren.Initialize()
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Layer View')
self.show()
def __init__(self, input=None, MinOpacity=0.0, MaxOpacity=0.1) :
import qt
import vtk
from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
self.__MinOpacity__ = MinOpacity
self.__MaxOpacity__ = MaxOpacity
# every QT app needs an app
self.__app__ = qt.QApplication(['itkviewer'])
# create the widget
self.__widget__ = QVTKRenderWindowInteractor()
self.__ren__ = vtk.vtkRenderer()
self.__widget__.GetRenderWindow().AddRenderer(self.__ren__)
self.__itkvtkConverter__ = None
self.__volumeMapper__ = vtk.vtkVolumeTextureMapper2D()
self.__volume__ = vtk.vtkVolume()
self.__volumeProperty__ = vtk.vtkVolumeProperty()
self.__volume__.SetMapper(self.__volumeMapper__)
self.__volume__.SetProperty(self.__volumeProperty__)
self.__ren__.AddVolume(self.__volume__)
self.__outline__ = None
self.__outlineMapper__ = None
self.__outlineActor__ = None
self.AdaptColorAndOpacity(0, 255)
if input :
self.SetInput(input)
self.AdaptColorAndOpacity()
def _create_pipeline(self):
# setup our pipeline
self._otf = vtk.vtkPiecewiseFunction()
self._ctf = vtk.vtkColorTransferFunction()
self._volume_property = vtk.vtkVolumeProperty()
self._volume_property.SetScalarOpacity(self._otf)
self._volume_property.SetColor(self._ctf)
self._volume_property.ShadeOn()
self._volume_property.SetAmbient(0.1)
self._volume_property.SetDiffuse(0.7)
self._volume_property.SetSpecular(0.2)
self._volume_property.SetSpecularPower(10)
self._volume_raycast_function = vtk.vtkVolumeRayCastMIPFunction()
self._volume_mapper = vtk.vtkVolumeRayCastMapper()
# can also used FixedPoint, but then we have to use:
# SetBlendModeToMaximumIntensity() and not SetVolumeRayCastFunction
#self._volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
self._volume_mapper.SetVolumeRayCastFunction(
self._volume_raycast_function)
module_utils.setup_vtk_object_progress(self, self._volume_mapper,
'Preparing render.')
self._volume = vtk.vtkVolume()
self._volume.SetProperty(self._volume_property)
self._volume.SetMapper(self._volume_mapper)
def __init__(self, img, color):
self.volume = vtk.vtkVolume()
self.__color = color
dataImporter = vtk.vtkImageImport()
simg = np.ascontiguousarray(img, np.uint8)
dataImporter.CopyImportVoidPointer(simg.data, len(simg.data))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
dataImporter.SetWholeExtent(0, simg.shape[2]-1, 0, simg.shape[1]-1, 0, simg.shape[0]-1)
self.__smoother = vtk.vtkImageGaussianSmooth()
self.__smoother.SetStandardDeviation(1, 1, 1)
self.__smoother.SetInputConnection(dataImporter.GetOutputPort())
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(self.__smoother.GetOutputPort())
self.__volumeProperty = vtk.vtkVolumeProperty()
self.__colorFunc = vtk.vtkColorTransferFunction()
self.__alpha = vtk.vtkPiecewiseFunction()
for i in range(256):
self.__colorFunc.AddRGBPoint(i, i * color[0], i * color[1], i * color[2])
self.__alpha.AddPoint(5, .01)
self.__alpha.AddPoint(10, .03)
self.__alpha.AddPoint(50, .1)
self.__alpha.AddPoint(150, .2)
self.__volumeProperty.SetColor(self.__colorFunc)
self.__volumeProperty.SetScalarOpacity(self.__alpha)
self.volume.SetMapper(volumeMapper)
self.volume.SetProperty(self.__volumeProperty)
def volumeRender(reader,ren,renWin): #Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(1, 0.0) opacityTransferFunction.AddPoint(100, 0.1) opacityTransferFunction.AddPoint(255,1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0,0.0,0.0,0.0) colorTransferFunction.AddRGBPoint(64.0,1.0,0.0,0.0) colorTransferFunction.AddRGBPoint(128.0,0.0,0.0,1.0) colorTransferFunction.AddRGBPoint(192.0,0.0,1.0,0.0) colorTransferFunction.AddRGBPoint(255.0,0.0,0.2,0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren.RemoveAllViewProps() ren.AddVolume(volume) ren.SetBackground(1,1,1) renWin.Render()
def _createPipeline(self):
# setup our pipeline
self._splatMapper = vtkdevide.vtkOpenGLVolumeShellSplatMapper()
self._splatMapper.SetOmegaL(0.9)
self._splatMapper.SetOmegaH(0.9)
# high-quality rendermode
self._splatMapper.SetRenderMode(0)
self._otf = vtk.vtkPiecewiseFunction()
self._otf.AddPoint(0.0, 0.0)
self._otf.AddPoint(0.9, 0.0)
self._otf.AddPoint(1.0, 1.0)
self._ctf = vtk.vtkColorTransferFunction()
self._ctf.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
self._ctf.AddRGBPoint(0.9, 0.0, 0.0, 0.0)
self._ctf.AddRGBPoint(1.0, 1.0, 0.937, 0.859)
self._volumeProperty = vtk.vtkVolumeProperty()
self._volumeProperty.SetScalarOpacity(self._otf)
self._volumeProperty.SetColor(self._ctf)
self._volumeProperty.ShadeOn()
self._volumeProperty.SetAmbient(0.1)
self._volumeProperty.SetDiffuse(0.7)
self._volumeProperty.SetSpecular(0.2)
self._volumeProperty.SetSpecularPower(10)
self._volume = vtk.vtkVolume()
self._volume.SetProperty(self._volumeProperty)
self._volume.SetMapper(self._splatMapper)
def get_volume(self, color_file=None, volume_opacity=0.25):
"""
Default Volume Rendering
Return vtkActor. For volume rendering it is vtkVolume
"""
if not self.flag_read:
sys.stderr.write('No Image Loaded.')
return
# TEST
print self.is_blank_image()
transfer_func = self.get_transfer_functioin(color_file, volume_opacity)
prop_volume = vtk.vtkVolumeProperty()
prop_volume.ShadeOff()
prop_volume.SetColor(transfer_func[0])
prop_volume.SetScalarOpacity(transfer_func[1])
prop_volume.SetGradientOpacity(transfer_func[2])
prop_volume.SetInterpolationTypeToLinear()
prop_volume.SetAmbient(0.4)
prop_volume.SetDiffuse(0.6)
prop_volume.SetSpecular(0.2)
mapper = vtk.vtkSmartVolumeMapper()
mapper.SetRequestedRenderMode(0)
# mapper = vtk.vtkGPUVolumeRayCastMapper()
mapper.SetInputData(self.reader)
actor = vtk.vtkVolume()
actor.SetMapper(mapper)
actor.SetProperty(prop_volume)
return actor
def volumeRender(img, tf=[],spacing=[1.0,1.0,1.0]):
importer = numpy2VTK(img,spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(),0,0,0,0])
tf.append([img.max(),1,1,1,1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def __init__(self, name, image_data):
if not isinstance(image_data, vtk.vtkImageData):
raise TypeError("input has to be vtkImageData")
self.name = name
# Create transfer mapping scalar value to opacity.
opacity_function = vtk.vtkPiecewiseFunction()
opacity_function.AddPoint(0, 0.0)
opacity_function.AddPoint(127, 0.0)
opacity_function.AddPoint(128, 0.2)
opacity_function.AddPoint(255, 0.2)
# Create transfer mapping scalar value to color.
color_function = vtk.vtkColorTransferFunction()
color_function.SetColorSpaceToHSV()
color_function.AddHSVPoint(0, 0.0, 0.0, 0.0)
color_function.AddHSVPoint(127, 0.0, 0.0, 0.0)
color_function.AddHSVPoint(128, 0.0, 0.0, 1.0)
color_function.AddHSVPoint(255, 0.0, 0.0, 1.0)
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_function)
volume_property.SetScalarOpacity(opacity_function)
volume_property.ShadeOn()
volume_property.SetInterpolationTypeToLinear()
volume_mapper = vtk.vtkSmartVolumeMapper()
volume_mapper.SetInputData(image_data)
self.volume = vtk.vtkVolume()
self.volume.SetMapper(volume_mapper)
self.volume.SetProperty(volume_property)
def RenderVTKVolume(image, volprops):
volmap = vtk.vtkVolumeRayCastMapper()
volmap.SetVolumeRayCastFunction(vtk.vtkVolumeRayCastCompositeFunction())
volmap.SetInputConnection(image.GetOutputPort())
vol = vtk.vtkVolume()
vol.SetMapper(volmap)
vol.SetProperty(volprops)
#Standard VTK stuff
ren = vtk.vtkRenderer()
ren.AddVolume(vol)
ren.SetBackground((1, 1, 1))
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(ren)
istyle = vtk.vtkInteractorStyleSwitch()
istyle.SetCurrentStyleToTrackballCamera()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renwin)
iren.SetInteractorStyle(istyle)
renwin.Render()
iren.Start()
def rebuildVolume( self ):
self.volume = vtk.vtkVolume()
self.volume.SetMapper( self.volumeMapper )
self.volume.SetScale( 1.0, 1.0, 1.0 )
self.volume.SetMapper(self.volumeMapper)
self.volume.SetProperty(self.volumeProperty)
self.volume.SetPosition( self.pos )
self.setVolRenderCfg( None, False )
self.renderer.AddVolume( self.volume )
def _create_pipeline(self):
# setup our pipeline
self._volume_property = vtk.vtkVolumeProperty()
self._volume_property.ShadeOn()
self._volume_mapper = None
self._volume = vtk.vtkVolume()
self._volume.SetProperty(self._volume_property)
self._volume.SetMapper(self._volume_mapper)
def __init__ (self, mod_m):
debug ("In Volume::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.actor = self.act = vtk.vtkVolume ()
self.data_out = self.mod_m.GetOutput ()
self._initialize ()
self._gui_init ()
self.legend = VolumeLegend(self.renwin, mod_m)
self.legend.update_lut(self.actor.GetProperty())
self.renwin.add_actors(self.legend.get_scalar_bar())
self.renwin.Render ()
Common.state.idle ()
def test_wrap_vtk(self):
"""Test if the wrap_vtk function works."""
o = vtk.vtkVolume()
w = tvtk_helper.wrap_vtk(o)
self.assertEqual(w.__class__.__name__, 'Volume')
w1 = tvtk_helper.wrap_vtk(w)
self.assertEqual(w, w1)
del w1, w, o
class A:
pass
a = A()
w = tvtk_helper.wrap_vtk(a)
self.assertEqual(a, w)
def volumeRender(img, tf=[], spacing=[1.0, 1.0, 1.0]):
importer = numpy2VTK(img, spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(), 0, 0, 0, 0])
tf.append([img.max(), 1, 1, 1, 1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
# working on the GPU
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# # The property describes how the data will look
# volProperty = vtk.vtkVolumeProperty()
# volProperty.SetColor(color_tf)
# volProperty.SetScalarOpacity(opacity_tf)
# volProperty.ShadeOn()
# volProperty.SetInterpolationTypeToLinear()
# # working on the CPU
# #volMapper = vtk.vtkVolumeRayCastMapper()
# volMapper = vtkFixedPointVolumeRayCastMapper()
# #compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# #compositeFunction.SetCompositeMethodToInterpolateFirst()
# #volMapper.SetVolumeRayCastFunction(compositeFunction)
# volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
#volProperty.ShadeOn()
#volProperty.SetInterpolationTypeToLinear()
# Do the lines below speed things up?
pix_diag = 5.0
volMapper.SetSampleDistance(pix_diag / 1.0)
volProperty.SetScalarOpacityUnitDistance(pix_diag)
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def BuildView(self):
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
if self.Volume:
self.vmtkRenderer.Renderer.RemoveVolume(self.Volume)
if (self.ArrayName != ''):
self.Image.GetPointData().SetActiveScalars(self.ArrayName)
scalarRange = [0.0, 0.0]
if self.WindowLevel[0] > 0.0:
scalarRange = [
self.WindowLevel[1] - self.WindowLevel[0] / 2.0,
self.WindowLevel[1] + self.WindowLevel[0] / 2.0
]
else:
scalarRange = self.Image.GetScalarRange()
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(scalarRange[0], 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(scalarRange[1], 1.0, 1.0, 1.0)
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInput(self.Image)
volumeMapper.SetBlendModeToMaximumIntensity()
if self.AutoSampleDistance:
volumeMapper.AutoAdjustSampleDistancesOn()
else:
volumeMapper.SetSampleDistance(self.SampleDistance)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetColor(colorTransferFunction)
self.Volume = vtk.vtkVolume()
self.Volume.SetMapper(volumeMapper)
self.Volume.SetProperty(volumeProperty)
self.vmtkRenderer.Renderer.AddVolume(self.Volume)
if (self.Display == 1):
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def load_volume(filename):
reader = vtk.vtkMetaImageReader()
reader.SetFileName(filename)
reader.Update()
(xMin, xMax, yMin, yMax, zMin,
zMax) = reader.GetExecutive().GetWholeExtent(
reader.GetOutputInformation(0))
(xSpacing, ySpacing, zSpacing) = reader.GetOutput().GetSpacing()
(x0, y0, z0) = reader.GetOutput().GetOrigin()
print(f'Origin: {(x0, y0, z0)}')
print(f'Extents: min: {(xMin, yMin, zMin)}')
print(f' max: {(xMax, yMax, zMax)}')
center = [
x0 + xSpacing * 0.5 * (xMin + xMax),
y0 + ySpacing * 0.5 * (yMin + yMax),
z0 + zSpacing * 0.5 * (zMin + zMax)
]
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(130, 0.01)
alphaChannelFunc.AddPoint(400, 0.27)
alphaChannelFunc.AddPoint(650, 0.9)
alphaChannelFunc.AddPoint(1106, 1.0)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
colorFunc.AddRGBPoint(400, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(650, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(230, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(1106, 0.0, 0.0, 1.0)
# The previous two classes stored properties.
# Because we want to apply these properties to the volume we want to render,
# we have to store them in a class that stores volume properties.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.CroppingOn()
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The class vtkVolume is used to pair the previously declared volume as well as the properties
# to be used when rendering that volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.SetPickable(False)
return volume, reader.GetOutputPort()
def volumeRender(img, tf=[],spacing=[1.0,1.0,1.0]):
importer = numpy2VTK(img,spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(),0,0,0,0])
tf.append([img.max(),1,1,1,1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
# working on the GPU
# volMapper = vtk.vtkGPUVolumeRayCastMapper()
# volMapper.SetInputConnection(importer.GetOutputPort())
# # The property describes how the data will look
# volProperty = vtk.vtkVolumeProperty()
# volProperty.SetColor(color_tf)
# volProperty.SetScalarOpacity(opacity_tf)
# volProperty.ShadeOn()
# volProperty.SetInterpolationTypeToLinear()
# working on the CPU
volMapper = vtk.vtkVolumeRayCastMapper()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
compositeFunction.SetCompositeMethodToInterpolateFirst()
volMapper.SetVolumeRayCastFunction(compositeFunction)
volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
# Do the lines below speed things up?
# pix_diag = 5.0
# volMapper.SetSampleDistance(pix_diag / 5.0)
# volProperty.SetScalarOpacityUnitDistance(pix_diag)
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def BuildView(self):
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
if self.Volume:
self.vmtkRenderer.Renderer.RemoveVolume(self.Volume)
if (self.ArrayName != ''):
self.Image.GetPointData().SetActiveScalars(self.ArrayName)
scalarRange = [0.0, 0.0]
if self.WindowLevel[0] > 0.0:
scalarRange = [self.WindowLevel[1] - self.WindowLevel[0]/2.0, self.WindowLevel[1] + self.WindowLevel[0]/2.0]
else:
scalarRange = self.Image.GetScalarRange()
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(scalarRange[0], 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(scalarRange[1], 1.0, 1.0, 1.0)
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInput(self.Image)
volumeMapper.SetBlendModeToMaximumIntensity()
if self.AutoSampleDistance:
volumeMapper.AutoAdjustSampleDistancesOn()
else:
volumeMapper.SetSampleDistance(self.SampleDistance)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetColor(colorTransferFunction)
self.Volume = vtk.vtkVolume()
self.Volume.SetMapper(volumeMapper)
self.Volume.SetProperty(volumeProperty)
self.vmtkRenderer.Renderer.AddVolume(self.Volume)
if (self.Display == 1):
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def __init__(self, data_dir, opacityL, opacityH):
# Read the data
filename = "vol_t00_x5_70_d4pt5_inner.vti"
vSource = vtk.vtkXMLImageDataReader()
vSource.SetFileName(filename)
vSource.Update()
#blocks = reader1.GetOutput()
#b0 = blocks.GetBlock(0)
# Setup VTK environment
#Create a mapper and actor
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(opacityL, 0.0)
opacityTransferFunction.AddPoint(opacityH, 0.8)
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.2, 0.4)
#colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
#colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
#volumeProperty.SetGradientOpacity(gradientTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
#volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetAmbient(1.0)
volumeProperty.SetDiffuse(0.7)
volumeProperty.SetSpecular(0.5)
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(vSource.GetOutputPort())
#volumeMapper.CroppingOn()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.Update()
#renderer.AddVolume(volume)
# Mapper
#glyph_mapper = vtk.vtkPolyDataMapper()
#glyph_mapper.SetInputConnection(glyphs.GetOutputPort())
#glyph_actor = vtk.vtkActor()
#glyph_actor.SetMapper(glyph_mapper)
#self.b0 = b0
self.volume = volume
self.vSource = vSource
def test_wrap_vtk(self):
"""Test if the wrap_vtk function works."""
o = vtk.vtkVolume()
w = tvtk_helper.wrap_vtk(o)
self.assertEqual(w.__class__.__name__, 'Volume')
w1 = tvtk_helper.wrap_vtk(w)
self.assertEqual(w, w1)
del w1, w, o
class A:
pass
a = A()
w = tvtk_helper.wrap_vtk(a)
self.assertEqual(a, w)
def load_atlas(path, intensities, signs):
'''
path: path to atlas file
opacity: opacity of overlayed atlas brain
'''
nifti_reader = vtk.vtkNIFTIImageReader()
nifti_reader.SetFileName(path)
nifti_reader.Update()
# intensities = intensities/math.sqrt(np.mean(intensities**2))
# The following class is used to store transparencyv-values for later
# retrival. In our case, we want the value 0 to be completly opaque
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
for i in range(len(intensities)):
alphaChannelFunc.AddPoint(i + 1, intensities[i])
# This class stores color data and can create color tables from a few color
# points. For this demo, we want the three cubes to be of the colors red
# green and blue.
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
for i in range(len(signs)):
if signs[i] < 0: colorFunc.AddRGBPoint(i + 1, 0.0, 0.0, intensities[i])
elif signs[i] > 0:
colorFunc.AddRGBPoint(i + 1, intensities[i], 0.0, 0.0)
else:
colorFunc.AddRGBPoint(i + 1, 1.0, 1.0, 1.0)
# The previous two classes stored properties. Because we want to apply
# these properties to the volume we want to render, we have to store them
# in a class that stores volume prpoperties.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
# We can finally create our volume. We also have to specify the data for
# it, as well as how the data will be rendered.
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputDataObject(nifti_reader.GetOutput())
# The class vtkVolume is used to pair the preaviusly declared volume as
# well as the properties to be used when rendering that volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return volume
def load_atlas(path, intensities, signs):
'''
path: path to atlas file
opacity: opacity of overlayed atlas brain
'''
nifti_reader = vtk.vtkNIFTIImageReader()
nifti_reader.SetFileName(path)
nifti_reader.Update()
# intensities = intensities/math.sqrt(np.mean(intensities**2))
# The following class is used to store transparencyv-values for later
# retrival. In our case, we want the value 0 to be completly opaque
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
for i in range(len(intensities)):
alphaChannelFunc.AddPoint(i+1, intensities[i])
# This class stores color data and can create color tables from a few color
# points. For this demo, we want the three cubes to be of the colors red
# green and blue.
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
for i in range(len(signs)):
if signs[i] < 0: colorFunc.AddRGBPoint(i+1, 0.0, 0.0, intensities[i])
elif signs[i] > 0: colorFunc.AddRGBPoint(i+1, intensities[i], 0.0, 0.0)
else: colorFunc.AddRGBPoint(i+1, 1.0, 1.0, 1.0)
# The previous two classes stored properties. Because we want to apply
# these properties to the volume we want to render, we have to store them
# in a class that stores volume prpoperties.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
# We can finally create our volume. We also have to specify the data for
# it, as well as how the data will be rendered.
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputDataObject(nifti_reader.GetOutput())
# The class vtkVolume is used to pair the preaviusly declared volume as
# well as the properties to be used when rendering that volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return volume
def save_vtk_image(images, dst, i):
image_import = vtk.vtkImageImport()
image_import.CopyImportVoidPointer(images.tostring(), len(images.tostring()))
image_import.SetDataScalarTypeToUnsignedChar()
image_import.SetNumberOfScalarComponents(1)
image_import.SetDataExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1)
image_import.SetWholeExtent(0, images.shape[2] - 1, 0, images.shape[1] - 1, 0, images.shape[0] - 1)
volume = vtk.vtkVolume()
volume_mapper = vtk.vtkVolumeRayCastMapper()
alpha_channel_func = vtk.vtkPiecewiseFunction()
alpha_channel_func.AddPoint(0, 0.0)
# alpha_channel_func.AddPoint(64, 0.3)
# alpha_channel_func.AddPoint(128, 0.5)
alpha_channel_func.AddPoint(100, 1.0)
alpha_channel_func.ClampingOn()
color_func = vtk.vtkPiecewiseFunction()
color_func.AddPoint(5, 0.3)
color_func.AddPoint(25, 0.5)
color_func.AddPoint(125, 0.7)
color_func.AddPoint(255, 1.0)
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_func)
volume_property.SetInterpolationTypeToLinear()
volume_property.SetScalarOpacity(alpha_channel_func)
volume.SetProperty(volume_property)
volume_ray_cast_func = vtk.vtkVolumeRayCastMIPFunction()
volume_mapper.SetInputConnection(image_import.GetOutputPort())
volume_mapper.SetVolumeRayCastFunction(volume_ray_cast_func)
# volume_mapper.SetSampleDistance(1)
# volume_mapper.SetAutoAdjustSampleDistances(0)
# volume_mapper.SetImageSampleDistance(1)
volume.SetMapper(volume_mapper)
ren = vtk.vtkRenderer()
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1024, 1024)
renWin.AddRenderer(ren)
renWin.Render()
window_2_image = vtk.vtkWindowToImageFilter()
window_2_image.SetInput(renWin)
window_2_image.Update()
png_writer = vtk.vtkPNGWriter()
png_writer.SetFileName(dst + '%05d'%(i) + '.png')
png_writer.SetInput(window_2_image.GetOutput())
png_writer.Write()
def __init__(self):
'''
Constructor
'''
vtkPythonViewImage.__init__(self)
# texture mapper in 3D: vtkVolumeMapper
self.__VolumeMapper = None
# texture mapper in 3D: vtkVolumeTextureMapper3D
self.__VolumeTextureMapper = vtk.vtkVolumeTextureMapper3D()
# volume ray cast mapper vtkFixedPointVolumeRayCastMapper
self.__VolumeRayCastMapper = vtk.vtkFixedPointVolumeRayCastMapper()
# volume property: vtkVolumeProperty
self.__VolumeProperty = vtk.vtkVolumeProperty()
# volume actor: vtkVolume
self.__VolumeActor = vtk.vtkVolume()
# opacity transfer function: vtkPiecewiseFunction
self.__OpacityFunction = vtk.vtkPiecewiseFunction()
# color transfer function: vtkColorTransferFunction
self.__ColorFunction = vtk.vtkColorTransferFunction()
# vtkProp3DCollection
self.__PhantomCollection = vtk.vtkProp3DCollection()
# blender: vtkImageBlend
self.__Blender = None
# image 3D cropping box callback: vtkImage3DCroppingBoxCallback
self.__Callback = vtkPythonImage3DCroppingBoxCallback()
# box widget: vtkOrientedBoxWidget
# self.__BoxWidget = vtkOrientedBoxWidget() # Now I could not wrap vtkOrientedBoxWidget
self.__BoxWidget = vtk.vtkBoxWidget()
# vtkPlane widget: vtkPlaneWidget
self.__PlaneWidget = vtk.vtkPlaneWidget()
# annotated cube actor: vtkAnnotatedCubeActor, vtkOrientationMarkerWidget
self.__Cube = vtk.vtkAnnotatedCubeActor()
self.__Marker = vtk.vtkOrientationMarkerWidget()
self.SetupVolumeRendering()
self.SetupWidgets()
self.ShowAnnotationsOn()
self.getTextProperty().SetColor(0, 0, 0)
self.SetBackground(0.9, 0.9, 0.9) # white
self.__FirstRender = 1
self.__RenderingMode = self.PLANAR_RENDERING
self.__VRQuality = 1
self.__InteractorStyleSwitcher = None
def main():
#alphaChannelFunc = vtk.vtkPiecewiseFunction()
#alphaChannelFunc.AddPoint(0, 0.0)
#volumeProperty = vtk.vtkVolumeProperty()
#volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInputConnection(fromVid2Vtk(args))
volumeMapper.SetBlendModeToComposite()
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(20, 0.0)
opacityTransferFunction.AddPoint(255, 0.2)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
#volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.Update()
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.AddVolume(volume)
renderer.SetBackground(1, 1, 1)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def volume_render(self, scalar_range):
i1 = scalar_range[0]
i2 = scalar_range[1]
i3 = scalar_range[2]
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInputData(self.volume)
# The color transfer function maps voxel intensities to colors.
# It is modality-specific, and often anatomy-specific as well.
# The goal is to one color for flesh (between 500 and 1000)
# and another color for bone (1150 and over).
volumeColor = vtk.vtkColorTransferFunction()
volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0)
volumeColor.AddRGBPoint(i1, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(i2, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(i3, 1.0, 1.0, 0.9)
# The opacity transfer function is used to control the opacity
# of different tissue types.
volumeScalarOpacity = vtk.vtkPiecewiseFunction()
volumeScalarOpacity.AddPoint(0, 0.00)
volumeScalarOpacity.AddPoint(i1, 0.15)
volumeScalarOpacity.AddPoint(i2, 0.15)
volumeScalarOpacity.AddPoint(i3, 0.85)
# The gradient opacity function is used to decrease the opacity
# in the "flat" regions of the volume while maintaining the opacity
# at the boundaries between tissue types. The gradient is measured
# as the amount by which the intensity changes over unit distance.
# For most medical data, the unit distance is 1mm.
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(0, 0.0)
volumeGradientOpacity.AddPoint(90, 0.5)
volumeGradientOpacity.AddPoint(100, 1.0)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(volumeColor)
volumeProperty.SetScalarOpacity(volumeScalarOpacity)
volumeProperty.SetGradientOpacity(volumeGradientOpacity)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.4)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.graphics.renderer.AddViewProp(volume)
def volumeRendering(image, image2, lowerThreshold, upperThreshold):
color = vtk.vtkColorTransferFunction()
color.AddRGBPoint(0, 0.0, 0.0, 0.0) # background
color.AddRGBPoint(lowerThreshold, 1.0, 0.0, 0.0)
color.AddRGBPoint(upperThreshold, 0.0, 1.0, 0.0)
opacity = vtk.vtkPiecewiseFunction()
opacity.AddPoint(0, 0.0)
opacity.AddPoint(lowerThreshold, 0.15)
opacity.AddPoint(upperThreshold, 0.85)
gradient = vtk.vtkPiecewiseFunction()
gradient.AddPoint(0, 0.0)
gradient.AddPoint(90, 0.5)
gradient.AddPoint(100, 1.0)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(color)
volumeProperty.SetScalarOpacity(opacity)
volumeProperty.SetGradientOpacity(gradient)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.2)
volumeProperty.SetDiffuse(0.7)
volumeProperty.SetSpecular(0.3)
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInputData(image)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.Update()
ren = vtk.vtkRenderer()
ren.AddViewProp(volume)
ren.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(400, 400)
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
renWin.Render()
iren.Start()
def main(argv):
if len(argv) < 2:
print "usage:",argv[0]," data.nrrd data.cmap"
exit(1)
data_fn = argv[1]
cmap_fn = argv[2]
reader = vtk.vtkPNrrdReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
# opacity function
opacityFunction = vtk.vtkPiecewiseFunction()
# color function
colorFunction = vtk.vtkColorTransferFunction()
cmap = open(cmap_fn, 'r')
for line in cmap.readlines():
parts = line.split()
value = float(parts[0])
r = float(parts[1])
g = float(parts[2])
b = float(parts[3])
a = float(parts[4])
opacityFunction.AddPoint(value, a)
colorFunction.AddRGBPoint(value, r, g, b)
# volume setup:
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunction)
volumeProperty.SetScalarOpacity(opacityFunction)
# composite function (using ray tracing)
compositeFunction = vtk.vtkVolumeRayCastMIPFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(data)
# make the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# renderer
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.AddVolume(volume)
renderer.SetBackground(0,0,0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def draw_voxels(self):
self.show_axes = False
u = self.data['voxels']
u /= (2 * max([abs(min(u)), abs(max(u))]))
u += 0.5
u *= 255
nx, ny, nz = u.shape
U = asarray(u, dtype=uint8)
dstr = U.tostring()
img = vtkImageImport()
img.CopyImportVoidPointer(dstr, len(dstr))
img.SetDataScalarTypeToUnsignedChar()
img.SetNumberOfScalarComponents(1)
img.SetDataExtent(0, nz - 1, 0, ny - 1, 0, nx - 1)
img.SetWholeExtent(0, nz - 1, 0, ny - 1, 0, nx - 1)
self.gradient = gradient = vtkPiecewiseFunction()
gradient.AddPoint(1, 0.0)
gradient.AddPoint(255, 0.2)
self.cbar = cbar = vtkColorTransferFunction()
cbar.AddRGBPoint(0.0, 0.0, 0.0, 1.0)
cbar.AddRGBPoint(42.0, 0.0, 0.5, 1.0)
cbar.AddRGBPoint(84.0, 0.0, 1.0, 0.5)
cbar.AddRGBPoint(128.0, 0.0, 1.0, 0.0)
cbar.AddRGBPoint(168.0, 0.5, 1.0, 0.0)
cbar.AddRGBPoint(212.0, 1.0, 0.5, 0.0)
cbar.AddRGBPoint(255.0, 1.0, 0.0, 0.0)
self.volprop = volprop = vtkVolumeProperty()
volprop.SetColor(cbar)
volprop.SetScalarOpacity(gradient)
volprop.ShadeOff()
volprop.SetInterpolationTypeToLinear()
mapper = vtkFixedPointVolumeRayCastMapper()
mapper.SetInputConnection(img.GetOutputPort())
volume = vtkVolume()
volume.SetMapper(mapper)
volume.SetProperty(volprop)
self.main.renderer.AddVolume(volume)
self.main.camera.SetPosition(0, -2 * max([nx, ny, nz]), nz)
self.main.camera.SetFocalPoint(0.5 * nx, 0.5 * ny, 0.5 * nz)
def createVolumeRender(File, ScalarList, ColorList, OpacList, PieceList):
#Create the mappers
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(File.GetOutputPort())
volumeMapper.SetBlendModeToComposite()
#Create the color transfer function
volumeCTF = vtk.vtkColorTransferFunction()
volumeCTF.AddRGBPoint(ScalarList[0], ColorList[0][0], ColorList[0][1],
ColorList[0][2])
volumeCTF.AddRGBPoint(ScalarList[1], ColorList[1][0], ColorList[1][1],
ColorList[1][2])
volumeCTF.AddRGBPoint(ScalarList[2], ColorList[2][0], ColorList[2][1],
ColorList[2][2])
volumeCTF.AddRGBPoint(ScalarList[3], ColorList[3][0], ColorList[3][1],
ColorList[3][2])
#Create the piecewise function for opacity function
volumeOTF = vtk.vtkPiecewiseFunction()
volumeOTF.AddPoint(ScalarList[0], OpacList[0])
volumeOTF.AddPoint(ScalarList[1], OpacList[1])
volumeOTF.AddPoint(ScalarList[2], OpacList[2])
volumeOTF.AddPoint(ScalarList[3], OpacList[3])
#Create the piecewise function for internal opacity function
volumeGOTF = vtk.vtkPiecewiseFunction()
volumeGOTF.AddPoint(0, PieceList[0])
volumeGOTF.AddPoint(90, PieceList[1])
volumeGOTF.AddPoint(100, PieceList[2])
#Add all the function and ambient, diffuse and specular to the volume property
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(volumeCTF)
volumeProperty.SetScalarOpacity(volumeOTF)
volumeProperty.SetGradientOpacity(volumeGOTF)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.5)
volumeProperty.SetDiffuse(0.5)
volumeProperty.SetSpecular(0.5)
#Create volume and set mapper and property to volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
#Return volume
return volume
def volume_rendering(data, opacity, samp_dist=1.0, shade=True,
diffuse=1.0, renderer=None):
vmin,vmax = opacity.get_range()
vrange = float(vtk.VTK_UNSIGNED_SHORT_MAX-1)
crg0 = vrange/3.0
crg1 = vrange*2.0/3.0
scale = (crg1-crg0) / (vmax-vmin)
shift = -vmin + crg0/scale
clipped = data + shift
clipped *= scale
np.clip(clipped.data, 0, vrange, out=clipped.data)
image = RegData_to_vtkImageData(clipped, dtype=np.uint16)
ctf = opacity.get_vtkColorTransferFunction(scale, shift)
otf = opacity.get_vtkPiecewiseFunction(scale, shift)
volume = vtk.vtkVolume()
vol_prop = vtk.vtkVolumeProperty()
volume.SetProperty(vol_prop)
vol_prop.SetColor(ctf)
vol_prop.SetScalarOpacity(otf)
vol_prop.SetInterpolationTypeToLinear()
if shade:
vol_prop.ShadeOn()
else:
vol_prop.ShadeOff()
#
#vol_prop.SetAmbient(ambient) # no effect !
vol_prop.SetDiffuse(diffuse)
#vol_prop.SetSpecular(0)
vol_map = vtkGetVolumeRayCastMapper()
volume.SetMapper(vol_map)
vtkConnectDataInput(image, vol_map)
vol_map.SetSampleDistance(samp_dist*np.min(data.dx()))
if renderer is not None:
renderer.AddVolume(volume)
#
ctfbar = opacity.get_vtkLookupTable()
return volume, ctfbar
def _update_region(self, org_x, org_y, org_z, update_size):
'''
:param pa, pb, pc: Requires tuple format of 3 coordinates TCL
Update region inside the box constructed by pa, pb and pc
'''
for i in range(org_x, org_x + update_size):
for j in range(org_y, org_y + update_size):
for k in range(org_z, org_z + update_size):
self.reader.GetOutput().SetScalarComponentFromFloat(i, j, k, 0, 255)
# self.voi = vtk.vtkExtractVOI()
# self.voi.SetInputConnection(self.reader.GetOutputPort())
# self.voi.SetVOI(org_x, org_x + update_size,
# org_y, org_y + update_size,
# org_z, org_z + update_size)
# self.voi.Update()
self.regionMC = vtk.vtkImageMarchingCubes()
self.regionMC.SetInputConnection(self.reader.GetOutputPort())
self.regionMC.SetValue(0, self.ui.mc_spin.value())
self.regionMC.Update()
# self.mc.SetInputConnection(self.reader.GetOutputPort())
# self.mc.Update()
# self.appendData = vtk.vtkAppendPolyData()
# self.appendData.AddInputData(self.mc.GetOutput())
# self.appendData.AddInputData(self.regionMC.GetOutput())
# self.mapper.SetInputConnection(self.appendData.GetOutputPort())
self.mapper2 = vtk.vtkPolyDataMapper()
self.mapper2.SetInputConnection(self.regionMC.GetOutputPort())
self.volumeMapper = vtk.vtkVolumeMapper()
self.volumeMapper.SetCropping(1)
self.volumeMapper.SetCroppingRegionPlanes(org_x, org_x + update_size,
org_y, org_y + update_size,
org_z, org_z + update_size)
self.volumeMapper.SetCroppingRegionFlags(0x0002000)
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumeMapper)
self.upperRender = vtk.vtkRenderer()
self.upperRender.AddVolume(self.volume)
self.upperRender.SetBackground(0.9, 0.9, 0.9)
self.upperRender.SetLayer(2)
self.vtk3DWidget.GetRenderWindow().AddRenderer(self.upperRender)
def __init__(self, parent): wx.SplitterWindow.__init__(self, parent) # # setup the control panel # self.controlPanel = wx.lib.scrolledpanel.ScrolledPanel( self ) vBox = wx.BoxSizer( wx.VERTICAL ) self.mode = wx.RadioBox( self.controlPanel, label="Mode", choices=["2D", "3D"] ) vBox.Add( self.mode, 0, wx.EXPAND ) self.colorAndOpacityEditor = WrapITKColorAndOpacityEditor( self.controlPanel ) vBox.Add( self.colorAndOpacityEditor, 0, wx.EXPAND ) self.controlPanel.SetSizer( vBox ) self.controlPanel.SetupScrolling() # # setup the render window # from vtk.wx.wxVTKRenderWindowInteractor import wxVTKRenderWindowInteractor from vtk import vtkRenderer, vtkVolumeTextureMapper2D, vtkVolumeProperty, vtkVolume self.rendererWindow = wxVTKRenderWindowInteractor(self, -1) self.renderer = vtkRenderer() self.rendererWindow.GetRenderWindow().AddRenderer(self.renderer) self.volumeMapper = vtkVolumeTextureMapper2D() self.volume = vtkVolume() self.volumeProperty = vtkVolumeProperty() self.volumeProperty.SetScalarOpacity( self.colorAndOpacityEditor.opacityTransferFunction ) self.volumeProperty.SetColor( self.colorAndOpacityEditor.colorTransferFunction ) self.volume.SetMapper( self.volumeMapper ) self.volume.SetProperty( self.volumeProperty ) self.renderer.AddVolume( self.volume ) self.outline = None self.outlineMapper = None self.outlineActor = None # fill the split pane self.SplitVertically( self.controlPanel, self.rendererWindow ) # avoid loosing on panel or the other self.SetMinimumPaneSize( 1 ) # to manage update event correctly self.updateInProgress = False
def __init__(self, reader):
logging.info("begin Init ViewerVR")
self._reader = reader
#init VolumeRayCastMapper
self._volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
self._volumeMapper.SetSampleDistance(self._volumeMapper.GetSampleDistance()/2)
self._volumeMapper.SetBlendModeToComposite()
self._volumeMapper.SetInputConnection(reader.GetOutputPort())
self._volumeColor = vtk.vtkColorTransferFunction()
self._volumeScalarOpacity = vtk.vtkPiecewiseFunction()
self._volumeGradientOpacity = vtk.vtkPiecewiseFunction()
self._volumeProperty = vtk.vtkVolumeProperty()
self._volume = vtk.vtkVolume()
self._render = vtk.vtkRenderer()
logging.info("End Init ViewerVR")
def open_another_volume_and_tf(self, volume_filename, tf_filename): self.ui.setWindowTitle(volume_filename) opacityTransferFunction, colorTransferFunction = load_transfer_function(tf_filename) plot_tf(opacityTransferFunction, colorTransferFunction) # Create the reader for the data reader = vtk.vtkMetaImageReader() reader.SetFileName(volume_filename) # store the filenames and vtk reader for later use self.volume_filename = volume_filename self.tf_filename = tf_filename self.reader = reader # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # for vtkGPUVolumeRayCastMapper volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.ren = vtk.vtkRenderer() self.ren.AddVolume(volume) self.ren.SetBackground(1, 1, 1) window = self.vtkWidget.GetRenderWindow() collection = window.GetRenderers() item = collection.GetNextItem() while item is not None: window.RemoveRenderer(item) item = collection.GetNextItem() window.AddRenderer(self.ren) window.Render() self.iren.Initialize()
def setupImageProcessingPipeline(self):
# Caster
self.caster = vtk.vtkImageShiftScale()
self.caster.SetOutputScalarTypeToUnsignedChar()
self.caster.ClampOverflowOn()
# Setup composite ray cast function
self.rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction()
# Add to mapper
self.volumeMapper = vtk.vtkVolumeRayCastMapper()
self.volumeMapper.SetInputConnection(self.caster.GetOutputPort())
self.volumeMapper.SetVolumeRayCastFunction(self.rayCastFunction)
# The color transfer function maps voxel intensities to colors.
self.volumeColor = vtk.vtkColorTransferFunction()
self.volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0)
self.volumeColor.AddRGBPoint(255, 1.0, 1.0, 1.0)
# The opacity transfer function (tissue opacity)
self.volumeScalarOpacity = vtk.vtkPiecewiseFunction()
self.volumeScalarOpacity.AddPoint(0, 0.00)
self.volumeScalarOpacity.AddPoint(255, 1)
# The gradient opacity function (decrease opacity in flat regions)
self.volumeGradientOpacity = vtk.vtkPiecewiseFunction()
self.volumeGradientOpacity.AddPoint(0, 0.0)
self.volumeGradientOpacity.AddPoint(90, 0.5)
self.volumeGradientOpacity.AddPoint(100, 1.0)
# Property
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.volumeColor)
self.volumeProperty.SetScalarOpacity(self.volumeScalarOpacity)
self.volumeProperty.SetGradientOpacity(self.volumeGradientOpacity)
self.volumeProperty.SetInterpolationTypeToLinear()
self.volumeProperty.ShadeOn()
self.volumeProperty.SetAmbient(1)
self.volumeProperty.SetDiffuse(1)
self.volumeProperty.SetSpecular(0.2)
# Prop
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumeMapper)
self.volume.SetProperty(self.volumeProperty)
def opImplement(self):
opacity = vtk.vtkPiecewiseFunction();
#x is scaler value , y is opacity value
opacity.AddPoint(IMAGEOUT,0.0);
opacity.AddPoint(IMAGEIN ,1.0);
#x is scaler value , other is rgb value
color = vtk.vtkColorTransferFunction();
color.AddRGBPoint(IMAGEIN ,255.0/255.0,255.0/255.0,255.0/255.0);
volumeProperty = vtk.vtkVolumeProperty();
volumeProperty.ShadeOn();
volumeProperty.SetScalarOpacity(opacity)
volumeProperty.SetColor(color);
mapper = vtk.vtkSmartVolumeMapper();
mapper.SetInputData(self.data);
volume = vtk.vtkVolume();
volume.SetMapper(mapper);
volume.SetProperty(volumeProperty);
return volume;
def render_cloud(self):
self.ren.RemoveVolume(self.cloud_volume)
if not self.config["CLOUD"][0]:
return
data_path = compose_file_name(self.base_dir, "/CLOUD",
self.data_folders["CLOUD"],
self.time_step)
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(data_path)
reader.Update()
spacing = reader.GetOutput().GetSpacing()
reader.GetOutput().SetSpacing(spacing[0], spacing[1], spacing[2] * 30)
myrange = reader.GetOutput().GetPointData().GetScalars().GetRange()
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(myrange[0], 0.0)
opacityTransferFunction.AddPoint(myrange[1], 0.1)
color = vtk.vtkColorTransferFunction()
# Blue
color.AddRGBPoint(myrange[0], 0.8, 0.8, 0.8)
color.AddRGBPoint((myrange[0] + myrange[1]) / 2, 1., 1., 1)
color.AddRGBPoint(myrange[1], 0.8, 0.8, 0.8)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(color)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOff()
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetBlendModeToComposite()
volumeMapper.SetAutoAdjustSampleDistances(0)
volumeMapper.SetSampleDistance(0.5)
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.cloud_volume = volume
self.ren.AddVolume(volume)
def __init__(self, parent):
super(NeuroGLWidget, self).__init__(parent)
self.iren = self.GetRenderWindow().GetInteractor()
self.volume = vtk.vtkVolume()
self.GetRenderWindow().SetNumberOfLayers(2)
self.ren = []
for i in range(2):
self.ren.append(vtk.vtkRenderer())
self.ren[i].SetLayer(i)
self.GetRenderWindow().AddRenderer(self.ren[i])
#self.ren[i].GetActiveCamera().ParallelProjectionOn()
self.ren[1].SetActiveCamera(self.ren[0].GetActiveCamera())
self.ren[0].GetActiveCamera().ParallelProjectionOn()
self.style = InteractorStyle.MyInteractorStyle()
self.style.SetInteractor(self.iren)
self.style.SetRenderers(self.ren)
#self.style.SetRendererCollection(self.GetRenderWindow().GetRenderers())
self.style.AutoAdjustCameraClippingRangeOff()
self.iren.SetInteractorStyle(self.style)
self.style.SetGLWidgetHandle(self)
self.transform = vtk.vtkTransform()
self.transform.Identity()
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.onContextMenu)
self.volumeSize = [0, 0, 0] #d,h,w
self.volumeRes = [1, 1, 1] #d,h,w
self.outLine = vtk.vtkActor()
self.axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOutlineColor(1, 1, 1)
self.marker.SetOrientationMarker(self.axes)
self.marker.SetInteractor(self.GetRenderWindow().GetInteractor())
self.marker.SetViewport(0, 0, 0.1, 0.1)
self.marker.SetEnabled(True)
self.marker.InteractiveOn()
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.importData = vtk.vtkImageData()
self.colorFunc = vtk.vtkColorTransferFunction()
self.planeWidgetZ = vtkImagePlaneWidget()
self.planeWidgetZ.SetSliceIndex(0)
self.planeMode = False
self.CreateSliderWidget()
def makeVolumeRenderingPipeline(in_volume):
dataImporter = vtk.vtkImageImport()
if in_volume.dtype == numpy.uint8:
dataImporter.SetDataScalarTypeToUnsignedChar()
elif in_volume.dtype == numpy.uint16:
dataImporter.SetDataScalarTypeToUnsignedShort()
elif in_volume.dtype == numpy.int32:
dataImporter.SetDataScalarTypeToInt()
elif in_volume.dtype == numpy.int16:
dataImporter.SetDataScalarTypeToShort()
else:
raise RuntimeError("unknown data type %r of volume" %
(in_volume.dtype, ))
dataImporter.SetImportVoidPointer(in_volume, len(in_volume))
dataImporter.SetNumberOfScalarComponents(1)
extent = [
0, in_volume.shape[2] - 1, 0, in_volume.shape[1] - 1, 0,
in_volume.shape[0] - 1
]
dataImporter.SetDataExtent(*extent)
dataImporter.SetWholeExtent(*extent)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
for i in range(1, NOBJECTS):
alphaChannelFunc.AddPoint(i, 1.0)
colorFunc = vtk.vtkColorTransferFunction()
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return dataImporter, colorFunc, volume, volumeMapper
def createVolume(image):
'''
create volume of image - image must be a typical irm image with gray values comprised between 0 and 255
'''
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(10.0, 0.0)
opacityTransferFunction.AddPoint(40.0, 1.0)
opacityTransferFunction.AddPoint(60, 1.0)
opacityTransferFunction.AddPoint(200, 0.0)
opacityTransferFunction.AddPoint(255, 0.0)
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetDiffuse(0.7)
volumeProperty.SetSpecular(0.5)
volumeProperty.SetSpecularPower(70.0)
# mapper
volumeMapper=None
if 1:
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(image)
else:
volumeMapper = vtk.vtkVolumeTextureMapper2D()
volumeMapper.SetInput(image)
# volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return volume, volumeMapper
def initWindow(self, path):
self.vcolor = [[0, 0.0, 0.0, 0.0], [500, 0.6, 0.5, 0.3],
[1000, 0.9, 0.9, 0.3], [1150, 1.0, 1.0, 0.9]]
self.vOpacity = [[0, 0], [500, 0.55], [1000, 0.55], [1150, 0.85]]
self.gOpacity = [[0, 0.0], [90, 0.8], [100, 1.0]]
self.source = vtk.vtkDICOMImageReader()
self.source.SetDirectoryName(path)
self.source.Update()
self.volumcolors = vtk.vtkColorTransferFunction()
self.setOpacityColor(self.vcolor)
self.volumScalarOpacity = vtk.vtkPiecewiseFunction()
self.setOpacityValue(self.vOpacity)
self.volumGradientOpacity = vtk.vtkPiecewiseFunction()
self.setGradientOpacity(self.gOpacity)
self.volumMapper = vtk.vtkGPUVolumeRayCastMapper()
self.volumMapper.SetInputConnection(self.source.GetOutputPort())
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.volumcolors)
self.volumeProperty.SetScalarOpacity(self.volumScalarOpacity)
self.volumeProperty.SetGradientOpacity(self.volumGradientOpacity)
self.volumeProperty.SetInterpolationTypeToLinear()
self.volumeProperty.ShadeOn()
self.volumeProperty.SetAmbient(0.4)
self.volumeProperty.SetDiffuse(0.6)
self.volumeProperty.SetSpecular(0.2)
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumMapper)
self.volume.SetProperty(self.volumeProperty)
self.colors = vtk.vtkNamedColors()
self.colors.SetColor("BackGroundcolors", [255, 255, 255, 255])
self.ren.SetBackground(self.colors.GetColor3d("BackGroundcolors"))
self.ren.AddVolume(self.volume)
self.iren.Initialize()
pass
def getVolumeVolume(fname, rangelow, rangehigh, opacitylow, opacityhigh, color_transfer_func):
volreader = vtk.vtkStructuredPointsReader()
volreader.SetFileName(fname)
volreader.Update()
volrange = (rangelow, rangehigh)
imageShift = vtk.vtkImageShiftScale()
imageShift.SetShift(-1*volrange[0])
imageShift.SetScale(255.0/(volrange[1]-volrange[0]))
imageShift.SetOutputScalarTypeToUnsignedChar()
imageShift.SetInput(volreader.GetOutput())
extractVol = vtk.vtkExtractVOI()
if (options.xmax > -1 or options.ymax > -1 or options.zmax > -1):
if ( options.verbose): print " Extracting subvolume ..."
extractVol.SetVOI( options.zmin, options.zmax, options.ymin, options.ymax, options.xmin, options.xmax )
extractVol.SetInput(imageShift.GetOutput())
volume_mapper = vtk.vtkVolumeRayCastMapper()
volume_mapper.SetInput(extractVol.GetOutput())
composite_function = vtk.vtkVolumeRayCastCompositeFunction()
volume_mapper.SetVolumeRayCastFunction(composite_function)
# Setting opacity functions
opacity_transfer_func = vtk.vtkPiecewiseFunction()
opacity_transfer_func.AddPoint( 0, opacitylow )
opacity_transfer_func.AddPoint( 118, opacityhigh )
opacity_transfer_func.AddPoint( 138, opacityhigh )
opacity_transfer_func.AddPoint( 255, opacitylow )
# Adding colour and opacity to properties
volume_properties = vtk.vtkVolumeProperty()
volume_properties.SetColor( color_transfer_func )
volume_properties.SetScalarOpacity( opacity_transfer_func )
# Adding properties to volume
volume = vtk.vtkVolume()
volume.SetMapper( volume_mapper )
volume.SetProperty( volume_properties )
return ( volreader, volume )
def showVolume(self, vtkImageData, preserveState):
'''Shows volume of image.'''
producer = vtk.vtkTrivialProducer()
producer.SetOutput(vtkImageData)
flip = vtk.vtkImageFlip()
# flip over y axis
flip.SetFilteredAxis(1)
flip.SetInputConnection(producer.GetOutputPort())
mapper = vtk.vtkSmartVolumeMapper()
mapper.SetInputConnection(flip.GetOutputPort())
scalarRange = vtkImageData.GetScalarRange()
opacity = vtk.vtkPiecewiseFunction()
opacity.AddPoint(scalarRange[0], 0.2)
opacity.AddPoint(scalarRange[1], 0.9)
color = vtk.vtkColorTransferFunction()
color.AddRGBPoint(scalarRange[0], 0, 0, 0)
color.AddRGBPoint(scalarRange[1], 1, 1, 1)
prop = vtk.vtkVolumeProperty()
prop.ShadeOff()
prop.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
prop.SetColor(color)
prop.SetScalarOpacity(opacity)
# save tubes and property if preserving state
if preserveState and self.volume:
prop = self.volume.GetProperty()
self.volumeRenderer.RemoveViewProp(self.volume)
else:
self.volumeRenderer.RemoveAllViewProps()
self.volume = vtk.vtkVolume()
self.volume.SetMapper(mapper)
self.volume.SetProperty(prop)
self.volumeRenderer.AddViewProp(self.volume)
self.volumeRenderer.ResetCamera()
def volumeProperty(reader, opacityTransferFunction, colorTransferFunction):
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetSpecular(0.3)
volumeProperty.SetInterpolationTypeToLinear()
MIPFunction = vtk.vtkVolumeRayCastMIPFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetSampleDistance(1.0)
volumeMapper.SetInput(reader.GetOutput())
volumeMapper.SetVolumeRayCastFunction(MIPFunction)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.RotateX(-90)
return volume
def volumeProperty(reader, opacityTransferFunction, colorTransferFunction):
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetSpecular(0.3)
volumeProperty.SetInterpolationTypeToLinear()
MIPFunction = vtk.vtkVolumeRayCastMIPFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetSampleDistance(1.0)
volumeMapper.SetInput(reader.GetOutput())
volumeMapper.SetVolumeRayCastFunction(MIPFunction)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.RotateX(-90)
return volume
def volren(self):
filename = self.params.colour_file
self.volreader = vtk.vtkStructuredPointsReader()
self.volreader.SetFileName(filename)
self.volreader.Update()
#self.volreader.GetOutput().SetOrigin(1,1,1)
#volrange=self.volreader.GetOutput().GetScalarRange()
volrange = (-1.0, 1.0)
imageShift = vtk.vtkImageShiftScale()
imageShift.SetShift(-1 * volrange[0])
imageShift.SetScale(255.0 / (volrange[1] - volrange[0]))
imageShift.SetOutputScalarTypeToUnsignedChar()
imageShift.SetInput(self.volreader.GetOutput())
volume_mapper = vtk.vtkVolumeRayCastMapper()
volume_mapper.SetInput(imageShift.GetOutput())
composite_function = vtk.vtkVolumeRayCastCompositeFunction()
volume_mapper.SetVolumeRayCastFunction(composite_function)
color_transfer_func = vtk.vtkColorTransferFunction()
color_transfer_func.AddRGBPoint(0, 0.0, 0.0, 1.0)
color_transfer_func.AddRGBPoint((255 / 2) - 10, 0.0, 0.0, 1.0)
color_transfer_func.AddRGBPoint((255 / 2) + 10, 1.0, 0.0, 0.0)
color_transfer_func.AddRGBPoint(255, 1.0, 0.0, 0.0)
opacity_transfer_func = vtk.vtkPiecewiseFunction()
opacity_transfer_func.AddPoint(0, self.params.volumeopacitylow)
opacity_transfer_func.AddPoint(118, self.params.volumeopacityhigh)
opacity_transfer_func.AddPoint(138, self.params.volumeopacityhigh)
opacity_transfer_func.AddPoint(255, self.params.volumeopacitylow)
volume_properties = vtk.vtkVolumeProperty()
volume_properties.SetColor(color_transfer_func)
volume_properties.SetScalarOpacity(opacity_transfer_func)
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_properties)
self.ren.AddVolume(volume)
def DisplayVolume(self, vtk_image_data):
#Save vtk_image_data as global param
gldefIndex = gldef.GetGlobalDefLen()
gldef.SetValue(gldefIndex, vtk_image_data)
#VolumeProperty: Opacity
vtk_piecewisefunc = vtk.vtkPiecewiseFunction()
vtk_piecewisefunc.AddPoint(20, 0.0)
vtk_piecewisefunc.AddPoint(255, 0.2)
#VolumeProperty: Color
vtk_colortransfunc = vtk.vtkColorTransferFunction()
vtk_colortransfunc.AddRGBPoint(0.0, 0.0, 0.5, 0.0)
vtk_colortransfunc.AddRGBPoint(60.0, 1.0, 0.0, 0.0)
vtk_colortransfunc.AddRGBPoint(128.0, 0.2, 0.1, 0.9)
vtk_colortransfunc.AddRGBPoint(196.0, 0.27, 0.21, 0.1)
vtk_colortransfunc.AddRGBPoint(255.0, 0.8, 0.8, 0.8)
#VolumeProperty
vtk_volproperty = vtk.vtkVolumeProperty()
vtk_volproperty.SetColor(vtk_colortransfunc)
vtk_volproperty.SetScalarOpacity(vtk_piecewisefunc)
vtk_volproperty.ShadeOn()
vtk_volproperty.SetInterpolationTypeToLinear()
vtk_volproperty.SetAmbient(0.2)
vtk_volproperty.SetDiffuse(0.9)
vtk_volproperty.SetSpecular(0.2)
vtk_volproperty.SetSpecularPower(10)
self.vtk_volume_mapper.SetInputData(vtk_image_data)
vtk_volume = vtk.vtkVolume()
vtk_volume.SetMapper(self.vtk_volume_mapper)
vtk_volume.SetProperty(vtk_volproperty)
self.vtk_renderer.RemoveAllViewProps()
#Delete All Images
self.vtk_renderer.AddVolume(vtk_volume)
self.vtk_renderer.ResetCamera()
self.vtk_render_win.Render()
pass
def render_volume_data(self, vtk_img_data):
# Create transfer mapping scalar value to opacity
opacity_transfer_function = vtk.vtkPiecewiseFunction()
opacity_transfer_function.AddPoint(0, 0.0)
opacity_transfer_function.AddPoint(50, 0.0)
opacity_transfer_function.AddPoint(100, 0.8)
opacity_transfer_function.AddPoint(1200, 0.8)
# Create transfer mapping scalar value to color
color_transfer_function = vtk.vtkColorTransferFunction()
color_transfer_function.AddRGBPoint(0, 0.0, 0.0, 0.0)
color_transfer_function.AddRGBPoint(50, 0.0, 0.0, 0.0)
color_transfer_function.AddRGBPoint(100, 1.0, 0.0, 0.0)
color_transfer_function.AddRGBPoint(1200, 1.0, 0.0, 0.0)
# The property describes how the data will look
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_transfer_function)
volume_property.SetScalarOpacity(opacity_transfer_function)
volume_property.ShadeOff()
volume_property.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volume_mapper = vtk.vtkVolumeRayCastMapper()
volume_mapper.SetVolumeRayCastFunction(compositeFunction)
if vtk.VTK_MAJOR_VERSION <= 5:
volume_mapper.SetInput(vtk_img_data)
else:
volume_mapper.SetInputData(vtk_img_data)
volume_mapper.SetBlendModeToMaximumIntensity()
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_property)
self.ren.AddVolume(volume)
self.ren.ResetCamera()
self.iren.Initialize()
def volumeRender(self): #Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(1, 0.0) opacityTransferFunction.AddPoint(100, 0.1) opacityTransferFunction.AddPoint(255,1.0) colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0,0.0,0.0,0.0) colorTransferFunction.AddRGBPoint(64.0,1.0,0.0,0.0) colorTransferFunction.AddRGBPoint(128.0,0.0,0.0,1.0) colorTransferFunction.AddRGBPoint(192.0,0.0,1.0,0.0) colorTransferFunction.AddRGBPoint(255.0,0.0,0.2,0.0) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() volumeMapper.SetInputConnection(self.reader.GetOutputPort()) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddVolume(volume) ren.SetBackground(1,1,1) renWin.SetSize(600,600) renWin.Render() iren.Initialize() renWin.Render() iren.Start()
def makeVolumeRenderingPipeline(in_volume):
dataImporter = vtk.vtkImageImport()
if in_volume.dtype == numpy.uint8:
dataImporter.SetDataScalarTypeToUnsignedChar()
elif in_volume.dtype == numpy.uint16:
dataImporter.SetDataScalarTypeToUnsignedShort()
elif in_volume.dtype == numpy.int32:
dataImporter.SetDataScalarTypeToInt()
elif in_volume.dtype == numpy.int16:
dataImporter.SetDataScalarTypeToShort()
else:
raise RuntimeError("unknown data type %r of volume" % (in_volume.dtype,))
dataImporter.SetImportVoidPointer(in_volume, len(in_volume))
dataImporter.SetNumberOfScalarComponents(1)
extent = [0, in_volume.shape[2]-1, 0, in_volume.shape[1]-1, 0, in_volume.shape[0]-1]
dataImporter.SetDataExtent(*extent)
dataImporter.SetWholeExtent(*extent)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
for i in range(1, NOBJECTS):
alphaChannelFunc.AddPoint(i, 1.0)
colorFunc = vtk.vtkColorTransferFunction()
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
return dataImporter, colorFunc, volume, volumeMapper
def volumeRender(self, img, tf=[], spacing=[1.0, 1.0, 1.0]):
importer = self.numpy2VTK(img, spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(), 0, 0, 0, 0])
tf.append([img.max(), 1, 1, 1, 1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
# working on the GPU
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
# if __name__ == "__main__":
# app = QApplication(sys.argv)
#
# window = dicomWidget()
# print(window.getInformation())
#
# sys.exit(app.exec_())
def createVlume(polyData, colorFunc, alphaChannelFunc, volumGradientOpacity,
spacings, position):
data_matrix = polyData
data_matrix = np.rot90(data_matrix, 1)
data_matrix = data_matrix.astype(np.uint8)
xSize, ySize, zSize = data_matrix.shape
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1)
dataImporter.SetWholeExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1)
dataImporter.SetDataExtentToWholeExtent()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.SetGradientOpacity(volumGradientOpacity)
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.4)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
transform = vtk.vtkTransform()
transform.Scale(spacings)
transform.Translate(position)
volume.SetUserTransform(transform)
return volume
def __init__(self, data_dir, opacityL, opacityH):
# Read the data
filename = "inclusions_all.vti"
vSource = vtk.vtkXMLImageDataReader()
vSource.SetFileName(filename)
vSource.Update()
#Create a mapper and actor
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(opacityL, 0.0)
opacityTransferFunction.AddPoint(opacityH, 0.8)
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.2, 0.4)
colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
volumeProperty = vtk.vtkVolumeProperty()
#volumeProperty.SetColor(colorTransferFunction)
#volumeProperty.SetGradientOpacity(gradientTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
#volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetAmbient(1.0)
volumeProperty.SetDiffuse(0.7)
volumeProperty.SetSpecular(0.5)
volumeMapper = vtk.vtkSmartVolumeMapper()
volumeMapper.SetInputConnection(vSource.GetOutputPort())
#volumeMapper.CroppingOn()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.Update()
#renderer.AddVolume(volume)
#self.b0 = b0
self.volume = volume
self.vSource = vSource
def loadImage(self, image_data):
r = image_data.GetScalarRange()
n = image_data.GetNumberOfScalarComponents()
print(r)
print(n)
# Create transfer mapping scalar value to opacity.
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(255, 1.0)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(10.0, 0.1, 0.1, 0.1)
colorTransferFunction.AddRGBPoint(255.0, 1.0, 1.0, 1.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data.
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputData(image_data)
volumeMapper.SetBlendModeToComposite()
volumeMapper.Update()
# The volume holds the mapper and the property and
# can be used to position/orient the volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.ren.AddVolume(volume)
self.ren.ResetCameraClippingRange()
self.ren.ResetCamera()
self.renWin().Render()
def __init__(self, cmData, reslice=None):
self.cmData = cmData
self._min = 0
self._max = 255
self.dataImport = vtk.vtkImageImport()
self.dataImport.SetDataScalarTypeToUnsignedChar()
self.dataImport.SetNumberOfScalarComponents(1)
self.alphaFunc = vtk.vtkPiecewiseFunction()
self.colorFunc = vtk.vtkColorTransferFunction()
self.setupColorFunc()
self.prop = vtk.vtkVolumeProperty()
self.prop.SetColor(self.colorFunc)
self.prop.SetScalarOpacity(self.alphaFunc)
self.mapper = vtk.vtkSmartVolumeMapper()
self.mapper.SetBlendModeToMaximumIntensity()
if reslice is not None:
reslice.SetInputConnection(self.dataImport.GetOutputPort())
self.mapper.SetInputConnection(reslice.GetOutputPort())
else:
self.mapper.SetInputConnection(self.dataImport.GetOutputPort())
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.mapper)
self.volume.SetProperty(self.prop)
