def main(argv):
if len(argv) < 2:
print "usage:",argv[0]," data.vtk"
exit(1)
data_fn = argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
updateColorOpacity()
# composite function (using ray tracing)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(data)
# make the volume
#volume = vtk.vtkVolume()
global volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# renderer
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderInteractor.AddObserver( vtk.vtkCommand.KeyPressEvent, keyPressed )
renderer.AddVolume(volume)
renderer.SetBackground(0,0,0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def __init__(self, data_reader):
#if vtk_structured_points_data!=None:
# ukosniki=vtk_structured_points_data.count("/")
# etykieta=vtk_structured_points_data.split("/",ukosniki)
# self.WhoAmI=self.WhoAmI+" "+ etykieta[ukosniki]
#def make_name(self,name):
# if name!=None:
# ukosniki=name.count("/")
# etykieta=name.split("/",ukosniki)
# self.WhoAmI=self.WhoAmI+" "+ etykieta[ukosniki]
self.make_color_function(data_reader.get_data_set().GetScalarRange())
# The property describes how the data will look
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.colorTransferFunction)
self.volumeProperty.SetScalarOpacity(self.opacityTransferFunction)
self.volumeProperty.SetGradientOpacity(self.gradientTransferFunction)
# The mapper / ray cast function know how to render the data
self.compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.cast = vtk.vtkImageCast()
self.cast.SetInput(data_reader.get_data_set())
self.cast.SetOutputScalarTypeToUnsignedShort()
self.cast.ClampOverflowOff()
self.mapper = vtk.vtkVolumeRayCastMapper()
self.mapper.SetVolumeRayCastFunction(self.compositeFunction)
self.mapper.SetInputConnection(self.cast.GetOutputPort())
self.actor = vtk.vtkVolume()
self.actor.SetMapper(self.mapper)
self.actor.SetProperty(self.volumeProperty)
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 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 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 main(argv):
if len(argv) < 2:
print "usage:", argv[0], " data.vtk"
exit(1)
data_fn = argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
updateColorOpacity()
# composite function (using ray tracing)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(data)
# make the volume
#volume = vtk.vtkVolume()
global volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# renderer
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderInteractor.AddObserver(vtk.vtkCommand.KeyPressEvent, keyPressed)
renderer.AddVolume(volume)
renderer.SetBackground(0, 0, 0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
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 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 vtkGetVolumeRayCastMapper():
if vtk.VTK_MAJOR_VERSION < 7:
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
vol_map = vtk.vtkVolumeRayCastMapper()
vol_map.SetVolumeRayCastFunction(compositeFunction)
else:
vol_map = vtk.vtkFixedPointVolumeRayCastMapper()
vol_map.SetBlendModeToComposite()
#
return vol_map
def _setup_for_raycast(self):
self._volume_raycast_function = \
vtk.vtkVolumeRayCastCompositeFunction()
self._volume_mapper = vtk.vtkVolumeRayCastMapper()
self._volume_mapper.SetVolumeRayCastFunction(
self._volume_raycast_function)
module_utils.setup_vtk_object_progress(self, self._volume_mapper,
'Preparing render.')
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)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
#compositeFunction.SetCompositeMethodToInterpolateFirst()
vol_map = vtk.vtkVolumeRayCastMapper()
vol_map.SetVolumeRayCastFunction(compositeFunction)
volume.SetMapper(vol_map)
#vol_map = vtk.vtkFixedPointVolumeRayCastMapper()
#vol_map = vtk.vtkVolumeTextureMapper3D()
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 __renderVolumn(self, shift, viewer_range):
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleSwitch())
ren = vtk.vtkRenderer()
ren.SetViewport(viewer_range)
self.renWin.AddRenderer(ren)
self.iren.SetRenderWindow(self.renWin)
# # Create transfer mapping scalar value to opacity
# 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)
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(50, 0.05)
opacityTransferFunction.AddPoint(100, 0.1)
opacityTransferFunction.AddPoint(150, 0.2)
# 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.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(50, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(100, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(150, 0.0, 0.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
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(shift.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)
ren.AddVolume(volume)
self.renWin.Render()
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()
global volumeProperty
volumeProperty.SetColor(colorFunction)
volumeProperty.SetScalarOpacity(opacityFunction)
# composite function (using ray tracing)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(data)
# make the volume
#volume = vtk.vtkVolume()
global volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# renderer
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderInteractor.AddObserver( vtk.vtkCommand.KeyPressEvent, keyPressed )
renderer.AddVolume(volume)
renderer.SetBackground(0,0,0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
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 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 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 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 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 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 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 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 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 mip_rendering(data, opacity, samp_dist=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()
vol_prop.ShadeOff()
mipf = vtk.vtkVolumeRayCastMIPFunction()
mipf.SetMaximizeMethodToScalarValue()
vol_map = vtk.vtkVolumeRayCastMapper()
vol_map.SetVolumeRayCastFunction(mipf)
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 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 set_map_type(self, map_type):
if map_type == self.map_type:
return
Common.state.busy ()
if map_type == 0:
self.map = vtk.vtkVolumeRayCastMapper ()
self.map.SetVolumeRayCastFunction (self.ray_cast_func)
elif map_type == 1:
self.map = vtk.vtkVolumeTextureMapper2D()
elif map_type == 2:
self.map = vtk.vtkVolumeProMapper()
self.renwin.get_active_camera().ParallelProjectionOn()
tkMessageBox.showwarning("Notice!","Camera's projection type set to parallel projection!")
self.map_type = map_type
self.map.SetInput (self.mod_m.GetOutput ())
self.act.SetMapper (self.map)
if self.root and self.root.winfo_exists():
self.make_map_gui()
self.make_rcf_gui()
self.renwin.Render ()
Common.state.idle ()
def volumeRender(self, imgData, tf, spacing=[1.0, 1.0, 1.0]):
# Returns a list of actors to be visualized based on a numpy array and image input
# input:
# img : vtk object
# tf : transfer function values to generate colouring from list of lists [val,r,g,v,op]
# spacing: imaging spacing
# Initialize transfer functions
opTF = vtk.vtkPiecewiseFunction()
colourTF = vtk.vtkColorTransferFunction()
for p in tf: # look through all of the transfer functions
colourTF.AddRGBPoint(p[0], p[1], p[2], p[3])
opTF.AddPoint(p[0], p[4])
# Use ray cast method to render volume
volMapper = vtk.vtkVolumeRayCastMapper()
compFunc = vtk.vtkVolumeRayCastCompositeFunction()
compFunc.SetCompositeMethodToInterpolateFirst()
volMapper.SetVolumeRayCastFunction(compFunc)
volMapper.SetInputConnection(imgData.GetOutputPort())
# set the volume properties from the transfer function
volProp = vtk.vtkVolumeProperty()
volProp.SetColor(colourTF)
volProp.SetScalarOpacity(opTF)
volProp.ShadeOn()
volProp.SetInterpolationTypeToLinear()
actor = vtk.vtkVolume()
actor.SetMapper(volMapper)
actor.SetProperty(volProp)
return actor
def vtkWidget(self, qFrame, filename=''):
# the center computation might seem to be a bit complicated however what we do is:
# the center_of_rotation gives the center of rotation in pixel coordinates
self.vl = QtWidgets.QGridLayout()
self.vtkWidget = QVTKRenderWindowInteractor(qFrame)
self.vl.addWidget(self.vtkWidget)
self.vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create an actor
self.arrowSource = vtk.vtkArrowSource()
self.focal_point = [0, 0, 0]
# self.reader = vtk.vtkSTLReader()
# self.reader.SetFileName(filename)
# self.reader.Update()
# polydata = self.reader.GetOutput()
testing = 0
if testing == 1:
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(
'C:\\Users\\jonas\\GitHub\\InteractiveConeBeamReconstruction\\shepplogan.vti'
)
reader.Update()
# Convert the image to a polydata
imageDataGeometryFilter = vtk.vtkImageDataGeometryFilter()
imageDataGeometryFilter.SetInputConnection(reader.GetOutputPort())
imageDataGeometryFilter.Update()
pdm = vtk.vtkPolyDataMapper()
pdm.SetInputConnection(imageDataGeometryFilter.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(pdm)
self.actor.GetProperty().SetPointSize(1)
print('x')
self.actor.GetProperty().SetRepresentationToWireframe()
elif testing == 2:
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(
'C:\\Users\\jonas\\GitHub\\InteractiveConeBeamReconstruction\\shepplogan.vti'
)
reader.Update()
castFilter = vtk.vtkImageCast()
castFilter.SetInputConnection(reader.GetOutputPort())
castFilter.SetOutputScalarTypeToUnsignedShort()
castFilter.Update()
imdataBrainSeg = castFilter.GetOutput()
propVolume = vtk.vtkVolumeProperty()
propVolume.ShadeOff()
# propVolume.SetColor(funcColor)
# propVolume.SetScalarOpacity(funcOpacityScalar)
# propVolume.SetGradientOpacity(funcOpacityGradient)
propVolume.SetInterpolationTypeToLinear()
funcRayCast = vtk.vtkVolumeRayCastCompositeFunction()
funcRayCast.SetCompositeMethodToClassifyFirst()
mapperVolume = vtk.vtkVolumeRayCastMapper()
mapperVolume.SetVolumeRayCastFunction(funcRayCast)
mapperVolume.SetInput(imdataBrainSeg)
actorVolume = vtk.vtkVolume()
actorVolume.SetMapper(mapperVolume)
actorVolume.SetProperty(propVolume)
self.actor = actorVolume
self.actor = vtk.vtkActor()
self.ren.AddActor(self.actor)
self.ren.SetBackground(0.0, 0.0, 0.0)
self.vtkWidget.Initialize()
self.iren.Initialize()
self.iren.SetInteractorStyle(InteractorStyle(parent=self.iren))
qFrame.setLayout(self.vl)
self.initial_camera = vtk.vtkCamera()
# self.initial_camera.SetPosition(100, 0, 1000)
self.initial_camera.DeepCopy(self.ren.GetActiveCamera())
#if filename:
# self.display_file(filename)
self.reset_view()
def addVol(self, data, header=None):
pix_diag = 5.0 / 10.0
img = vtkImageImportFromArray()
img.SetArray(data)
img.ConvertIntToUnsignedShortOn()
'''
Origin and Data spacing setting are essential for a normalized volume rendering of
the DWI image volumes
------- dawdling for a long time for addressing the problem that the volume is too thin
and even resorted to pre-resampling of the DWI volumes
'''
#img.GetImport().SetDataSpacing(0.9375, 0.9375, 4.5200)
img.GetImport().SetDataSpacing(header['pixdim'][1:4])
#img.GetImport().SetDataOrigin(128.0, 128.0, 68.50)
img.GetImport().SetDataOrigin(header['dim'][0] * header['pixdim'][0],
header['dim'][1] * header['pixdim'][1],
header['dim'][2] * header['pixdim'][2])
print img.GetDataExtent()
volMapper = vtk.vtkVolumeRayCastMapper()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
compositeFunction.SetCompositeMethodToInterpolateFirst()
#compositeFunction.SetCompositeMethodToClassifyFirst()
volMapper.SetVolumeRayCastFunction(compositeFunction)
volMapper.SetSampleDistance(pix_diag / 5.0)
volMapper.SetImageSampleDistance(1.0)
volMapper.SetInputConnection(img.GetOutputPort())
# The property describes how the data will look
self.volProperty = volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(self.color_tf)
volProperty.SetScalarOpacity(self.opacity_tf)
volProperty.SetGradientOpacity(self.opacity_tf)
if self.parent.lighting:
volProperty.ShadeOn()
#volProperty.SetInterpolationTypeToLinear()
volProperty.SetInterpolationTypeToNearest()
volProperty.SetScalarOpacityUnitDistance(pix_diag / 5.0)
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
self.ren.AddVolume(vol)
boxWidget = vtk.vtkBoxWidget()
boxWidget.SetInteractor(self.parent.m_ui.renderView)
boxWidget.SetPlaceFactor(1.0)
planes = vtk.vtkPlanes()
def ClipVolumeRender(obj, event):
obj.GetPlanes(planes)
volMapper.SetClippingPlanes(planes)
boxWidget.SetInput(img.GetOutput())
boxWidget.PlaceWidget(img.GetOutput().GetBounds())
boxWidget.InsideOutOn()
boxWidget.AddObserver("InteractionEvent", ClipVolumeRender)
outlineProperty = boxWidget.GetOutlineProperty()
outlineProperty.SetRepresentationToWireframe()
outlineProperty.SetAmbient(1.0)
outlineProperty.SetAmbientColor(1, 1, 1)
outlineProperty.SetLineWidth(3)
selectedOutlineProperty = boxWidget.GetSelectedOutlineProperty()
selectedOutlineProperty.SetRepresentationToWireframe()
selectedOutlineProperty.SetAmbient(1.0)
selectedOutlineProperty.SetAmbientColor(1, 0, 0)
selectedOutlineProperty.SetLineWidth(1)
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(img.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
self.ren.AddActor(outlineActor)
self.volnum += 1
def viz():
opaq = 0.01
# We begin by creating the data we want to render.
# For this tutorial, we create a 3D-image containing three overlaping cubes.
# This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
# The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
img = Image.open('imagen3.png').convert('L')
img = np.asarray(img)
print img.shape
Nx = sqrt(img.shape[0])
Ny = Nx
Nz = img.shape[1]
data_matrix = zeros([Nx, Ny, Nz], dtype=uint8)
for i in range(0,Nz-1):
temp = img[Nx*i:Nx*(i+1),:]
data_matrix[:,:,i] = np.uint8(255)-temp
#for i in range(0,maxcoordZ-1):
# for k in range(0,maxcoord-1):
# data_matrix[k,:,i] = np.uint8(255)-np.array(occupied[i*maxcoord2+k*maxcoord:i*maxcoord2+(k+1)*maxcoord]).astype(np.uint8)
#data_matrix = occupied#data_matrix[20:150, 20:150, 20:150] = randint(0,150)
# For VTK to be able to use the data, it must be stored as a VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The preaviusly created array is converted to a string of chars and imported.
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, Nx-1, 0, Ny-1, 0, Nz-1)
dataImporter.SetWholeExtent(0, Nx-1, 0, Ny-1, 0, Nz-1)
# The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be
# completly opaque whereas the three different cubes are given different transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0)
alphaChannelFunc.AddPoint(255, opaq)
# 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)
colorFunc.AddRGBPoint(255,0.8, 0.7, 0.6)
# The preavius 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)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# 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)
# With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0,0,0)
# ... and set window size.
renderWin.SetSize(800, 800)
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop.
renderWin.Render()
renderInteractor.Start()
def __init__(self, parent=None):
self.reader = vtk.vtkDICOMImageReader()
self.dataExtent = []
self.dataDimensions = []
self.dataRange = ()
# initialize GUI
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.ui.WindowCenterSlider.setRange(0, 1000)
self.ui.WindowWidthSlider.setRange(0, 1000)
# define viewers
[self.viewerXY, self.viewerYZ,
self.viewerXZ] = [vtk.vtkImageViewer2() for x in range(3)]
# attach interactors to viewers
self.viewerXY.SetupInteractor(self.ui.XYPlaneWidget)
self.viewerYZ.SetupInteractor(self.ui.YZPlaneWidget)
self.viewerXZ.SetupInteractor(self.ui.XZPlaneWidget)
# set render windows for viewers
self.viewerXY.SetRenderWindow(self.ui.XYPlaneWidget.GetRenderWindow())
self.viewerYZ.SetRenderWindow(self.ui.YZPlaneWidget.GetRenderWindow())
self.viewerXZ.SetRenderWindow(self.ui.XZPlaneWidget.GetRenderWindow())
# set slicing orientation for viewers
self.viewerXY.SetSliceOrientationToXZ()
self.viewerYZ.SetSliceOrientationToYZ()
self.viewerXZ.SetSliceOrientationToXY()
# rotate image
act = self.viewerYZ.GetImageActor()
act.SetOrientation(90, 0, 0)
# setup volume rendering
self.volRender = vtk.vtkRenderer()
self.volRenWin = self.ui.VolumeWidget.GetRenderWindow()
self.volRenWin.AddRenderer(self.volRender)
self.rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.volumeMapper = vtk.vtkVolumeRayCastMapper()
self.volumeMapper.SetVolumeRayCastFunction(self.rayCastFunction)
volumeColor = vtk.vtkColorTransferFunction()
volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0)
volumeColor.AddRGBPoint(500, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(1000, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(1150, 1.0, 1.0, 0.9)
self.volumeColor = volumeColor
volumeScalarOpacity = vtk.vtkPiecewiseFunction()
volumeScalarOpacity.AddPoint(0, 0.00)
volumeScalarOpacity.AddPoint(50, 0.15)
volumeScalarOpacity.AddPoint(100, 0.15)
volumeScalarOpacity.AddPoint(115, 0.85)
self.volumeScalarOpacity = volumeScalarOpacity
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(0, 0.0)
volumeGradientOpacity.AddPoint(100, 0.5)
volumeGradientOpacity.AddPoint(500, 1)
self.volumeGradientOpacity = volumeGradientOpacity
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)
self.volumeProperty = volumeProperty
volume = vtk.vtkVolume()
volume.SetMapper(self.volumeMapper)
volume.SetProperty(self.volumeProperty)
self.volume = volume
self.volRender.AddViewProp(volume)
def __init__(self):
#---------------------------------------------------------
# prep the volume for rendering at 128x128x128
self.ShiftScale = vtk.vtkImageShiftScale()
self.ShiftScale.SetOutputScalarTypeToUnsignedShort()
self.Reslice = vtk.vtkImageReslice()
self.Reslice.SetInput(self.ShiftScale.GetOutput())
self.Reslice.SetOutputExtent(0, 127, 0, 127, 0, 127)
self.Reslice.SetInterpolationModeToCubic()
#---------------------------------------------------------
# set up the volume rendering
self.Mapper = vtk.vtkVolumeRayCastMapper()
self.Mapper.SetInput(self.Reslice.GetOutput())
volumeFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.Mapper.SetVolumeRayCastFunction(volumeFunction)
self.Mapper3D = vtk.vtkVolumeTextureMapper3D()
self.Mapper3D.SetInput(self.Reslice.GetOutput())
self.Mapper2D = vtk.vtkVolumeTextureMapper2D()
self.Mapper2D.SetInput(self.Reslice.GetOutput())
self.Color = vtk.vtkColorTransferFunction()
self.Color.AddRGBPoint(0,0.0,0.0,0.0)
self.Color.AddRGBPoint(180,0.3,0.1,0.2)
self.Color.AddRGBPoint(1200,1.0,0.7,0.6)
self.Color.AddRGBPoint(2500,1.0,1.0,0.9)
self.ScalarOpacity = vtk.vtkPiecewiseFunction()
self.ScalarOpacity.AddPoint(0,0.0)
self.ScalarOpacity.AddPoint(180,0.0)
self.ScalarOpacity.AddPoint(1200,0.2)
self.ScalarOpacity.AddPoint(2500,0.8)
self.GradientOpacity = vtk.vtkPiecewiseFunction()
self.GradientOpacity.AddPoint(0,0.0)
self.GradientOpacity.AddPoint(90,0.5)
self.GradientOpacity.AddPoint(100,1.0)
self.Property = vtk.vtkVolumeProperty()
self.Property.SetColor(self.Color)
self.Property.SetScalarOpacity(self.ScalarOpacity)
#self.Property.SetGradientOpacity(self.GradientOpacity)
self.Property.SetInterpolationTypeToLinear()
self.Property.ShadeOff()
self.Property.SetAmbient(0.6)
self.Property.SetDiffuse(0.6)
self.Property.SetSpecular(0.1)
self.lod2D = self.AddLOD(self.Mapper2D, self.Property, 0.01)
self.lod3D = self.AddLOD(self.Mapper3D, self.Property, 0.1)
self.lodRC = self.AddLOD(self.Mapper, self.Property, 1.0)
self.SetLODLevel(self.lod2D, 2.0)
self.SetLODLevel(self.lod3D, 1.0)
self.SetLODLevel(self.lodRC, 0.0)
# disable ray casting
#self.DisableLOD(self.lod3D)
#self.DisableLOD(self.lod2D)
self.DisableLOD(self.lodRC)
def show3(data_matrix = None): # pragma: no coverage
import vtk
# We begin by creating the data we want to render.
# For this tutorial, we create a 3D-image containing three overlaping cubes.
# This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
# The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
import pdb; pdb.set_trace()
if data_matrix == None:
data_matrix = zeros([75, 75, 75], dtype=uint8)
data_matrix[0:35, 0:35, 0:35] = 50
data_matrix[25:55, 25:55, 25:55] = 100
data_matrix[45:74, 45:74, 45:74] = 150
else:
data_matrix[data_matrix==1] = 50
data_matrix[data_matrix==2] = 100
val0 = 0
val1 = 50
val2 = 100
val3 = 150
# For VTK to be able to use the data, it must be stored as a VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The preaviusly created array is converted to a string of chars and imported.
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
#dataImporter.SetDataExtent(0, 74, 0, 74, 0, 74)
#dataImporter.SetWholeExtent(0, 74, 0, 74, 0, 74)
dataImporter.SetDataExtent(0, data_matrix.shape[0]-1, 0, data_matrix.shape[1]-1, 0,data_matrix.shape[2]-1 )
dataImporter.SetWholeExtent(0, data_matrix.shape[0]-1, 0, data_matrix.shape[1]-1, 0,data_matrix.shape[2]-1 )
# The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be
# completly opaque whereas the three different cubes are given different transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(val0, 0.0)
alphaChannelFunc.AddPoint(val1, 0.05)
alphaChannelFunc.AddPoint(val2, 0.1)
alphaChannelFunc.AddPoint(val3, 0.2)
# 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(val1, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(val2, 0.0, 1.0, 0.0)
colorFunc.AddRGBPoint(val3, 0.0, 0.0, 1.0)
# The preavius 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)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# 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)
# With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0,0,0)
# ... and set window size.
renderWin.SetSize(400, 400)
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop.
renderWin.Render()
renderInteractor.Start()
import pdb; pdb.set_trace()
def VolumeRenderingDICOMLoader(dicomreader):
"""
(Not used)
:param dicomreader:
:return:
"""
imcast = vtk.vtkImageCast()
imcast.SetInputConnection(dicomreader.GetOutputPort())
imcast.SetOutputScalarTypeToUnsignedShort()
imcast.ClampOverflowOn()
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(-2048, 0, 0.5, 0)
opacityTransferFunction.AddPoint(142.677, 0, 0.5, 0)
opacityTransferFunction.AddPoint(145.016, 0.116071, 0.5, 0.26)
opacityTransferFunction.AddPoint(192.174, 0.5625, 0.469638, 0.39)
opacityTransferFunction.AddPoint(217.24, 0.776786, 0.666667, 0.41)
opacityTransferFunction.AddPoint(384.347, 0.830357, 0.5, 0)
opacityTransferFunction.AddPoint(3661, 0.830357, 0.5, 0)
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(-2048, 0, 0, 0, 0.5, 0)
colorTransferFunction.AddRGBPoint(142.667, 0, 0, 0, 0.5, 0)
colorTransferFunction.AddRGBPoint(145.016, 0.615686, 0, 0.156863, 0.5, 0.26)
colorTransferFunction.AddRGBPoint(192.174, 0.909804, 0.454902, 0, 0.469638, 0.39)
colorTransferFunction.AddRGBPoint(217.24, 0.972549, 0.807843, 0.611765, 0.666667, 0.41)
colorTransferFunction.AddRGBPoint(384.347, 0.909804, 0.909804, 1, 0.5, 0)
colorTransferFunction.AddRGBPoint(3661, 1, 1, 1, 0.5, 0)
colorTransferFunction.ClampingOn()
colorTransferFunction.SetColorSpace(1)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetAmbient(0.2)
volumeProperty.SetDiffuse(1)
volumeProperty.SetSpecular(0)
volumeProperty.SetSpecularPower(1)
volumeProperty.DisableGradientOpacityOn()
volumeProperty.SetComponentWeight(1, 1)
volumeProperty.SetScalarOpacityUnitDistance(0.48117)
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetInterpolationTypeToLinear()
raycast = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(raycast)
volumeMapper.SetInputConnection(imcast.GetOutputPort())
# volumeMapper.SetBlendModeToComposite()
volumeMapper.SetSampleDistance(0.1)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# === DEBUG TEST ===
# renderer = vtk.vtkRenderer()
# renderer.AddVolume(volume)
# vdisplay = xvfbwrapper.Xvfb()
# vdisplay.start()
#
# print "writing"
# ImageWriter(renderer, outFileName="tmp1")
# print "write 1..."
# camera = renderer.GetActiveCamera()
# camera.Zoom(1.3)
# camera.Azimuth(40)
# ImageWriter(renderer, camera=camera, outFileName="tmp2")
# print "write 2..."
# renderer.ResetCameraClippingRange()
# vdisplay.stop()
# === DEBUG TEST ===
return volume
def vtkCube(self, data_matrix=None):
# We begin by creating the data we want to render.
# For this tutorial, we create a 3D-image containing three overlaping cubes.
# This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
# The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
#data_matrix = zeros([75, 75, 75], dtype=uint8)
#data_matrix[0:35, 0:35, 0:35] = 50
#data_matrix[25:55, 25:55, 25:55] = 100
#data_matrix[45:74, 45:74, 45:74] = 150
# For VTK to be able to use the data, it must be stored as a VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The preaviusly created array is converted to a string of chars and imported.
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, 9, 0, 9, 0, 9)
dataImporter.SetWholeExtent(0, 9, 0, 9, 0, 9)
#dataImporter.SetDataExtent(0, 74, 0, 74, 0, 74)
#dataImporter.SetWholeExtent(0, 74, 0, 74, 0, 74)
# The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be
# completly opaque whereas the three different cubes are given different transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.6)
alphaChannelFunc.AddPoint(33, 0.2)
alphaChannelFunc.AddPoint(66, 0.1)
alphaChannelFunc.AddPoint(100, 0.01)
# Gradient opacity
# other way: misfit 0 is anti opacity
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(70, 1.0)
volumeGradientOpacity.AddPoint(50, 0.5)
volumeGradientOpacity.AddPoint(20, 0.0)
# 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(00, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(30, 0.0, 1.0, 0.0)
colorFunc.AddRGBPoint(60, 0.0, 0.0, 1.0)
# The preavius 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.SetGradientOpacity(volumeGradientOpacity)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOff()
volumeProperty.SetAmbient(0.1)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# 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)
# Text am Nullpunkt
atext = vtk.vtkVectorText()
atext.SetText("(0,0,0)")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(10, 10, 10)
textActor.AddPosition(0, -0.1, 78)
# Cube to give some orientation
# (from http://www.vtk.org/Wiki/VTK/Examples/Python/Widgets/OrientationMarkerWidget)
axesActor = vtk.vtkAnnotatedCubeActor()
axesActor.SetXPlusFaceText('N')
axesActor.SetXMinusFaceText('S')
axesActor.SetYMinusFaceText('W')
axesActor.SetYPlusFaceText('E')
axesActor.SetZMinusFaceText('D')
axesActor.SetZPlusFaceText('U')
axesActor.GetTextEdgesProperty().SetColor(1, 1, 0)
axesActor.GetTextEdgesProperty().SetLineWidth(2)
axesActor.GetCubeProperty().SetColor(0, 0, 1)
# With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axesActor)
axes.SetInteractor(renderInteractor)
axes.EnabledOn()
axes.InteractiveOn()
renderer.ResetCamera()
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0.7, 0.7, 0.7)
# ... and set window size.
renderWin.SetSize(400, 400)
# Fuege Text am Nullpunkt hinzu:
renderer.AddActor(textActor)
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop.
renderWin.Render()
renderInteractor.Start()
def vtkCube(self, data_matrix=None):
# We begin by creating the data we want to render.
# For this tutorial, we create a 3D-image containing three overlaping cubes.
# This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
# The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
#data_matrix = zeros([75, 75, 75], dtype=uint8)
#data_matrix[0:35, 0:35, 0:35] = 50
#data_matrix[25:55, 25:55, 25:55] = 100
#data_matrix[45:74, 45:74, 45:74] = 150
# For VTK to be able to use the data, it must be stored as a VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The preaviusly created array is converted to a string of chars and imported.
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer
# must be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this
# simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case.
# I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although
# VTK complains if not both are used.
dataImporter.SetDataExtent(0, 9, 0, 9, 0, 9)
dataImporter.SetWholeExtent(0, 9, 0, 9, 0, 9)
#dataImporter.SetDataExtent(0, 74, 0, 74, 0, 74)
#dataImporter.SetWholeExtent(0, 74, 0, 74, 0, 74)
# The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be
# completly opaque whereas the three different cubes are given different transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.6)
alphaChannelFunc.AddPoint(33, 0.2)
alphaChannelFunc.AddPoint(66, 0.1)
alphaChannelFunc.AddPoint(100, 0.01)
# Gradient opacity
# other way: misfit 0 is anti opacity
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(70, 1.0)
volumeGradientOpacity.AddPoint(50, 0.5)
volumeGradientOpacity.AddPoint(20, 0.0)
# 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(00, 1.0, 0.0, 0.0)
colorFunc.AddRGBPoint(30, 0.0, 1.0, 0.0)
colorFunc.AddRGBPoint(60, 0.0, 0.0, 1.0)
# The preavius 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.SetGradientOpacity(volumeGradientOpacity)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOff()
volumeProperty.SetAmbient(0.1)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# 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)
# Text am Nullpunkt
atext = vtk.vtkVectorText()
atext.SetText("(0,0,0)")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(10, 10, 10)
textActor.AddPosition(0, -0.1, 78)
# Cube to give some orientation
# (from http://www.vtk.org/Wiki/VTK/Examples/Python/Widgets/OrientationMarkerWidget)
axesActor = vtk.vtkAnnotatedCubeActor();
axesActor.SetXPlusFaceText('N')
axesActor.SetXMinusFaceText('S')
axesActor.SetYMinusFaceText('W')
axesActor.SetYPlusFaceText('E')
axesActor.SetZMinusFaceText('D')
axesActor.SetZPlusFaceText('U')
axesActor.GetTextEdgesProperty().SetColor(1,1,0)
axesActor.GetTextEdgesProperty().SetLineWidth(2)
axesActor.GetCubeProperty().SetColor(0,0,1)
# With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axesActor)
axes.SetInteractor(renderInteractor)
axes.EnabledOn()
axes.InteractiveOn()
renderer.ResetCamera()
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0.7,0.7,0.7)
# ... and set window size.
renderWin.SetSize(400, 400)
# Fuege Text am Nullpunkt hinzu:
renderer.AddActor(textActor)
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop.
renderWin.Render()
renderInteractor.Start()
def display(input, name):
def make_data_matrix(x, intensity):
return intensity * np.repeat(np.repeat(
np.repeat(x, v_res, axis=0), v_res, axis=1),
v_res,
axis=2)
dataImporter = vtk.vtkImageImport()
v_res = 3
dim = 32
edi = [0]
dm = [0]
eIs = [64]
dm[0] = make_data_matrix(input, eIs[0]).tostring()
edi[0] = vtk.vtkImageImport()
edi[0].CopyImportVoidPointer(dm[0], len(dm[0]))
edi[0].SetDataScalarTypeToUnsignedChar()
edi[0].SetNumberOfScalarComponents(1)
edi[0].SetDataExtent(0,
int(dim * v_res) - 1, 0,
int(dim * v_res) - 1, 0,
int(dim * v_res) - 1)
edi[0].SetWholeExtent(0,
int(dim * v_res) - 1, 0,
int(dim * v_res) - 1, 0,
int(dim * v_res) - 1)
# Prepare color and transparency values
colorFunc = vtk.vtkColorTransferFunction()
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(64, 1)
alphaChannelFunc.AddPoint(128, 1.0)
alphaChannelFunc.AddPoint(192, 1.0)
alphaChannelFunc.AddPoint(255, 1.0)
colorFunc.AddRGBPoint(0, 0.0, 0.0, 0.0)
colorFunc.AddRGBPoint(64, 0.0, 0.4, 0.8)
colorFunc.AddRGBPoint(128, 0.8, 0.0, 0.0)
colorFunc.AddRGBPoint(192, 0.8, 0.0, 0.7)
colorFunc.AddRGBPoint(255, 0.0, 0.8, 0.0)
# Prepare volume properties.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn(
) # Keep this on unless you want everything to look terrible
volumeProperty.SetInterpolationTypeToNearest()
# More VTK Bookkeeping stuff.
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# Specify the data and raycast methods for the rendered volumes.
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# Endpoint volumeMappers
evm = [0]
evm[0] = vtk.vtkVolumeRayCastMapper()
evm[0].SetVolumeRayCastFunction(compositeFunction)
evm[0].SetInputConnection(
edi[0].GetOutputPort()) # Prepare the volume for the draggable model.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.SetPosition([0, 0, 0])
# Endpoint volumes
ev = [0, 0, 0, 0]
vps = [[-200, -160, -280], [0, 150.0, -150.0], [0, -150.0, 150.0],
[0, 150.0, 150.0]]
ev[0] = vtk.vtkVolume()
ev[0].SetMapper(evm[0])
ev[0].SetProperty(volumeProperty)
ev[0].SetPosition(vps[0])
ev[0].DragableOff()
ev[0].PickableOff()
class MyInteractorStyle(vtk.vtkInteractorStyleSwitch):
def __init__(self, parent=None):
# Index indicating which models are currently selected for endpoints
self.ix = 0
# Togglable flag indicating if the center model is being dragged or not
self.drag = 0
# Picker
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.001)
# Initialize the render window
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
# Initialize the render interactor
renderInteractor = vtk.vtkRenderWindowInteractor()
style = MyInteractorStyle()
style.SetDefaultRenderer(renderer)
renderInteractor.SetInteractorStyle(
style
) # volume_set=volume,Lvolume_set = Lvolume, Rvolume_set = Rvolume))
renderInteractor.SetRenderWindow(renderWin)
renderer.AddVolume(ev[0])
renderer.AddVolume(volume)
# set background to white. Optionally change it to a fun color, like "Lifeblood of the Untenderized."
renderer.SetBackground(1.0, 1.0, 1.0)
renderWin.SetSize(500, 500)
# Exit function
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Add exit function
renderWin.AddObserver("AbortCheckEvent", exitCheck)
# initialize interactor
renderInteractor.Initialize()
# Start application!
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(20)
renderer.GetActiveCamera().Dolly(2.8)
renderer.ResetCameraClippingRange()
w2i = vtk.vtkWindowToImageFilter()
writer = vtk.vtkTIFFWriter()
w2i.SetInput(renderWin)
w2i.Update()
writer.SetInputConnection(w2i.GetOutputPort())
writer.SetFileName("./samples/" + name + ".png")
renderWin.Render()
# renderInteractor.Start()
writer.Write()
def RenderCubeInVTK(filename = 'test.cube', mindatum = 0.0, maxdatum = 0.0):
global renWin
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
#######################
# Read in Gaussian cube
#######################
CubeData = vtk.vtkGaussianCubeReader()
CubeData.SetFileName(filename)
CubeData.Update()
#Get intrinsic scale from data
scale = sum([x**2 for x in CubeData.GetTransform().GetScale()])
CubeData.SetHBScale(scale) #scaling factor to compute bonds with hydrogens
CubeData.SetBScale(scale) #scaling factor for other bonds
CubeData.Update()
###################
#Calculate scalings
#VTK only knows how to render integer data in the interval [0,255] or [0,65535]
#Here, we calculate scaling factors to map the cube data to the interval.
if mindatum == maxdatum == 0.0:
if DEBUG:
print "Autodetecting range"
mindatum, maxdatum = CubeData.GetGridOutput().GetPointData().GetScalars().GetRange()
# Find the remapped value that corresponds to zero
zeropoint = int(2**ColorDepth*(-mindatum)/(maxdatum-mindatum))
absmaxdatum = max(-mindatum, maxdatum)
maxnegativeintensity = min(1.0, 1.0 - (absmaxdatum - abs(mindatum))/absmaxdatum)
minnegativeintensity = 0.0
if zeropoint < 0:
minpositiveintensity = - zeropoint/(2**ColorDepth*absmaxdatum)
else:
minpositiveintensity = 0.0
maxpositiveintensity = min(1.0, 1.0 - (absmaxdatum - abs(maxdatum))/absmaxdatum)
if DEBUG:
print "Range plotted = [%f,%f]" % (mindatum, maxdatum)
print "Negative colors = [0,%d)" % max(0,zeropoint)
print "Negative intensities = [%f,%f]" % (maxnegativeintensity,minnegativeintensity)
print "Positive colors = (%d,%d)" % (max(0,zeropoint), 2**ColorDepth)
print "Positive intensities = [%f,%f]" % (minpositiveintensity,maxpositiveintensity)
print "On this scale, zero = %d" % zeropoint
################################
# Calculate opacity transfer map
#The code here differentiates between two cases:
#1. the scalar data are all positive, so it's just a simple linear ramp
#2. the scalar data are signed, so do two linear ramps
opacityTransferFunction = vtk.vtkPiecewiseFunction()
if zeropoint < 0:
opacityTransferFunction.AddPoint( 0, minpositiveintensity)
else:
opacityTransferFunction.AddPoint( 0, maxnegativeintensity)
opacityTransferFunction.AddPoint(zeropoint, 0.0)
opacityTransferFunction.AddPoint(2**ColorDepth-1, maxpositiveintensity)
opacityTransferFunction.ClampingOn()
###########################
# Create color transfer map
colorTransferFunction = vtk.vtkColorTransferFunction()
r1, g1, b1 = NegativeColor
r2, g2, b2 = PositiveColor
r0, g0, b0 = BackgroundColor
if zeropoint < 0:
colorTransferFunction.AddRGBPoint( 0, r1, g1, b1)
else:
colorTransferFunction.AddRGBPoint( 0, r1, g1, b1)
colorTransferFunction.AddRGBPoint(zeropoint-1, r1, g1, b1)
colorTransferFunction.AddRGBPoint(zeropoint , r0, g0, b0)
colorTransferFunction.AddRGBPoint(zeropoint+1, r2, g2, b2)
colorTransferFunction.AddRGBPoint(2**ColorDepth-1, r2, g2, b2)
########################
# Now apply the scalings
ScaledData = vtk.vtkImageShiftScale()
ScaledData.SetInput(CubeData.GetGridOutput())
ScaledData.SetShift(-mindatum)
ScaledData.SetScale((2**ColorDepth-1)/(maxdatum-mindatum))
if ColorDepth == 16:
ScaledData.SetOutputScalarTypeToUnsignedShort()
elif ColorDepth == 8:
ScaledData.SetOutputScalarTypeToUnsignedChar()
else:
print
print "Error! Unsupported color depth given"
print
print "valid values are 8 or 16"
print
raise ValueError
###############################
# Form combined coloring scheme
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(ScaledData.GetOutput())
#Create a coarse representation
#Actually a fake - won't display anything
compositeFunction2 = vtk.vtkVolumeRayCastIsosurfaceFunction()
compositeFunction2.SetIsoValue(2**ColorDepth-1)
volumeMapperCoarse = vtk.vtkVolumeRayCastMapper()
volumeMapperCoarse.SetVolumeRayCastFunction(compositeFunction2)
volumeMapperCoarse.SetInput(ScaledData.GetOutput())
# Create volumetric object to be rendered
# Use level of detail prop so that it won't take forever to look around
volume = vtk.vtkLODProp3D()
id1 = volume.AddLOD(volumeMapper, volumeProperty, 0.)
volume.SetLODProperty(id1, volumeProperty)
id2 = volume.AddLOD(volumeMapperCoarse, volumeProperty, 0.)
volume.SetLODProperty(id2, volumeProperty)
# At this point, we can position and orient the volume
#################################
# End of volumetric data pipeline
#################################
#########
#Contours
#########
contour = vtk.vtkContourFilter()
contour.SetInput(CubeData.GetGridOutput())
contour.SetNumberOfContours(1)
contour.SetValue(0, 0.0)
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInput(contour.GetOutput())
contourMapper.SetScalarRange(0,0)
contourMapper.GetLookupTable().SetNumberOfTableValues(1)
r0, g0, b0 = NodeColor
contourMapper.GetLookupTable().SetTableValue(0, r0, g0, b0, NodeAlpha)
contourActor = vtk.vtkLODActor()
contourActor.SetMapper(contourMapper)
contourActor.GetProperty().SetOpacity(NodeAlpha)
##########################################
# Create a wireframe outline of the volume
##########################################
frame = vtk.vtkOutlineFilter()
frame.SetInput(CubeData.GetGridOutput())
frameMapper = vtk.vtkPolyDataMapper()
frameMapper.SetInput(frame.GetOutput())
frameActor = vtk.vtkLODActor()
frameActor.SetMapper(frameMapper)
frameActor.GetProperty().SetColor(FrameColor)
frameActor.GetProperty().SetOpacity(FrameAlpha)
######################
# Draw balls for atoms
######################
Sphere = vtk.vtkSphereSource()
Sphere.SetThetaResolution(16)
Sphere.SetPhiResolution(16)
Sphere.SetRadius(0.4)
Glyph = vtk.vtkGlyph3D()
Glyph.SetInput(CubeData.GetOutput())
Glyph.SetColorMode(1)
Glyph.SetColorModeToColorByScalar()
Glyph.SetScaleModeToScaleByVectorComponents()
Glyph.SetSource(Sphere.GetOutput())
AtomsMapper = vtk.vtkPolyDataMapper()
AtomsMapper.SetInput(Glyph.GetOutput())
AtomsMapper.SetImmediateModeRendering(1)
AtomsMapper.UseLookupTableScalarRangeOff()
AtomsMapper.SetScalarVisibility(1)
AtomsMapper.SetScalarModeToDefault()
Atoms = vtk.vtkLODActor()
Atoms.SetMapper(AtomsMapper)
############
# Draw bonds
############
Tube = vtk.vtkTubeFilter()
Tube.SetInput(CubeData.GetOutput())
BondsMapper = vtk.vtkPolyDataMapper()
BondsMapper.SetInput(Tube.GetOutput())
Bonds = vtk.vtkLODActor()
Bonds.SetMapper(BondsMapper)
#######################
# Now compose the image
#######################
if DrawVolume:
ren.AddVolume(volume)
if DrawNodes:
ren.AddActor(contourActor)
if DrawFrame:
ren.AddActor(frameActor)
if DrawAtoms:
ren.AddActor(Atoms)
if DrawBonds:
ren.AddActor(Bonds)
ren.SetBackground(BackgroundColor)
renWin.SetSize(OutputHeight, OutputWidth)
######################################
# Let VTK do its magic and render away
######################################
renWin.Render()
###################################
# Now allow user to play with image
###################################
def Keypress(obj, event):
#This function handles keyboard interaction
key = obj.GetKeySym()
if key == 'd' or key == 'F13':
WriteToPNG()
elif key == 'h' or key == 'question' or key =='?':
PrintHelp()
elif key == 'c':
camera = ren.GetActiveCamera()
print "Camera info:"
print "------------"
print "Position is: ", camera.GetPosition()
print "Focal point is:", camera.GetFocalPoint()
print "Orientation is:", ren.GetActiveCamera().GetOrientation()
print "WXYZ", ren.GetActiveCamera().GetOrientationWXYZ()
print "View up direction is:", camera.GetViewUp()
print "Direction of projection is:", camera.GetDirectionOfProjection()
else:
if DEBUG:
print 'User pressed key:', key
if Interactive:
iren.SetDesiredUpdateRate(25.0) #25 fps when camera is moving around
iren.SetStillUpdateRate(0.0) #0 fps when camera is not moving
iren.Initialize()
#The default interaction style is joystick, which seems unnatural
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.AddObserver("KeyPressEvent", Keypress)
iren.Start()
else:
WriteToPNG()
def volume(vol,voxsz=(1.0,1.0,1.0),affine=None,center_origin=1,info=1,maptype=0,trilinear=1,iso=0,iso_thr=100,opacitymap=None,colormap=None):
''' Create a volume and return a volumetric actor using volumetric rendering.
This function has many different interesting capabilities. The maptype, opacitymap and colormap are the most crucial parameters here.
Parameters:
----------------
vol : array, shape (N, M, K), dtype uint8
an array representing the volumetric dataset that we want to visualize using volumetric rendering
voxsz : sequence of 3 floats
default (1., 1., 1.)
affine : array, shape (4,4), default None
as given by volumeimages
center_origin : int {0,1}, default 1
it considers that the center of the volume is the
point (-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5)
info : int {0,1}, default 1
if 1 it prints out some info about the volume, the method and the dataset.
trilinear: int {0,1}, default 1
Use trilinear interpolation, default 1, gives smoother rendering. If you want faster interpolation use 0 (Nearest).
maptype : int {0,1}, default 0,
The maptype is a very important parameter which affects the raycasting algorithm in use for the rendering.
The options are:
If 0 then vtkVolumeTextureMapper2D is used.
If 1 then vtkVolumeRayCastFunction is used.
iso : int {0,1} default 0,
If iso is 1 and maptype is 1 then we use vtkVolumeRayCastIsosurfaceFunction which generates an isosurface at
the predefined iso_thr value. If iso is 0 and maptype is 1 vtkVolumeRayCastCompositeFunction is used.
iso_thr : int, default 100,
if iso is 1 then then this threshold in the volume defines the value which will be used to create the isosurface.
opacitymap : array, shape (N,2), default None.
The opacity map assigns a transparency coefficient to every point in the volume.
The default value uses the histogram of the volume to calculate the opacitymap.
colormap : array, shape (N,4), default None.
The color map assigns a color value to every point in the volume.
When None from the histogram it uses a red-blue colormap.
Returns:
----------
vtkVolume
Notes:
--------
What is the difference between TextureMapper2D and RayCastFunction?
Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs.
What is the difference between RayCastIsosurfaceFunction and RayCastCompositeFunction?
Coming soon... See VTK user's guide [book] & The Visualization Toolkit [book] and VTK's online documentation & online docs.
What about trilinear interpolation?
Coming soon... well when time permits really ... :-)
Examples:
------------
First example random points
>>> from dipy.viz import fos
>>> import numpy as np
>>> vol=100*np.random.rand(100,100,100)
>>> vol=vol.astype('uint8')
>>> print vol.min(), vol.max()
>>> r = fos.ren()
>>> v = fos.volume(vol)
>>> fos.add(r,v)
>>> fos.show(r)
Second example with a more complicated function
>>> from dipy.viz import fos
>>> import numpy as np
>>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
>>> s = np.sin(x*y*z)/(x*y*z)
>>> r = fos.ren()
>>> v = fos.volume(s)
>>> fos.add(r,v)
>>> fos.show(r)
If you find this function too complicated you can always use mayavi.
Please do not forget to use the -wthread switch in ipython if you are running mayavi.
>>> from enthought.mayavi import mlab
>>> import numpy as np
>>> x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
>>> s = np.sin(x*y*z)/(x*y*z)
>>> mlab.pipeline.volume(mlab.pipeline.scalar_field(s))
>>> mlab.show()
More mayavi demos are available here:
http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/mlab.html
'''
if vol.ndim!=3:
raise ValueError('3d numpy arrays only please')
if info :
print('Datatype',vol.dtype,'converted to uint8' )
vol=np.interp(vol,[vol.min(),vol.max()],[0,255])
vol=vol.astype('uint8')
if opacitymap==None:
bin,res=np.histogram(vol.ravel())
res2=np.interp(res,[vol.min(),vol.max()],[0,1])
opacitymap=np.vstack((res,res2)).T
opacitymap=opacitymap.astype('float32')
'''
opacitymap=np.array([[ 0.0, 0.0],
[50.0, 0.9]])
'''
if info:
print 'opacitymap', opacitymap
if colormap==None:
bin,res=np.histogram(vol.ravel())
res2=np.interp(res,[vol.min(),vol.max()],[0,1])
zer=np.zeros(res2.shape)
colormap=np.vstack((res,res2,zer,res2[::-1])).T
colormap=colormap.astype('float32')
'''
colormap=np.array([[0.0, 0.5, 0.0, 0.0],
[64.0, 1.0, 0.5, 0.5],
[128.0, 0.9, 0.2, 0.3],
[196.0, 0.81, 0.27, 0.1],
[255.0, 0.5, 0.5, 0.5]])
'''
if info:
print 'colormap', colormap
im = vtk.vtkImageData()
im.SetScalarTypeToUnsignedChar()
im.SetDimensions(vol.shape[0],vol.shape[1],vol.shape[2])
#im.SetOrigin(0,0,0)
#im.SetSpacing(voxsz[2],voxsz[0],voxsz[1])
im.AllocateScalars()
for i in range(vol.shape[0]):
for j in range(vol.shape[1]):
for k in range(vol.shape[2]):
im.SetScalarComponentFromFloat(i,j,k,0,vol[i,j,k])
if affine != None:
aff = vtk.vtkMatrix4x4()
aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],affine[0,3],affine[1,0],affine[1,1],affine[1,2],affine[1,3],affine[2,0],affine[2,1],affine[2,2],affine[2,3],affine[3,0],affine[3,1],affine[3,2],affine[3,3]))
#aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],0,affine[1,0],affine[1,1],affine[1,2],0,affine[2,0],affine[2,1],affine[2,2],0,affine[3,0],affine[3,1],affine[3,2],1))
#aff.DeepCopy((affine[0,0],affine[0,1],affine[0,2],127.5,affine[1,0],affine[1,1],affine[1,2],-127.5,affine[2,0],affine[2,1],affine[2,2],-127.5,affine[3,0],affine[3,1],affine[3,2],1))
reslice = vtk.vtkImageReslice()
reslice.SetInput(im)
#reslice.SetOutputDimensionality(2)
#reslice.SetOutputOrigin(127,-145,147)
reslice.SetResliceAxes(aff)
#reslice.SetOutputOrigin(-127,-127,-127)
#reslice.SetOutputExtent(-127,128,-127,128,-127,128)
#reslice.SetResliceAxesOrigin(0,0,0)
#print 'Get Reslice Axes Origin ', reslice.GetResliceAxesOrigin()
#reslice.SetOutputSpacing(1.0,1.0,1.0)
reslice.SetInterpolationModeToLinear()
#reslice.UpdateWholeExtent()
#print 'reslice GetOutputOrigin', reslice.GetOutputOrigin()
#print 'reslice GetOutputExtent',reslice.GetOutputExtent()
#print 'reslice GetOutputSpacing',reslice.GetOutputSpacing()
changeFilter=vtk.vtkImageChangeInformation()
changeFilter.SetInput(reslice.GetOutput())
#changeFilter.SetInput(im)
if center_origin:
changeFilter.SetOutputOrigin(-vol.shape[0]/2.0+0.5,-vol.shape[1]/2.0+0.5,-vol.shape[2]/2.0+0.5)
print 'ChangeFilter ', changeFilter.GetOutputOrigin()
opacity = vtk.vtkPiecewiseFunction()
for i in range(opacitymap.shape[0]):
opacity.AddPoint(opacitymap[i,0],opacitymap[i,1])
color = vtk.vtkColorTransferFunction()
for i in range(colormap.shape[0]):
color.AddRGBPoint(colormap[i,0],colormap[i,1],colormap[i,2],colormap[i,3])
if(maptype==0):
property = vtk.vtkVolumeProperty()
property.SetColor(color)
property.SetScalarOpacity(opacity)
if trilinear:
property.SetInterpolationTypeToLinear()
else:
prop.SetInterpolationTypeToNearest()
if info:
print('mapper VolumeTextureMapper2D')
mapper = vtk.vtkVolumeTextureMapper2D()
if affine == None:
mapper.SetInput(im)
else:
#mapper.SetInput(reslice.GetOutput())
mapper.SetInput(changeFilter.GetOutput())
if (maptype==1):
property = vtk.vtkVolumeProperty()
property.SetColor(color)
property.SetScalarOpacity(opacity)
property.ShadeOn()
if trilinear:
property.SetInterpolationTypeToLinear()
else:
prop.SetInterpolationTypeToNearest()
if iso:
isofunc=vtk.vtkVolumeRayCastIsosurfaceFunction()
isofunc.SetIsoValue(iso_thr)
else:
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
if info:
print('mapper VolumeRayCastMapper')
mapper = vtk.vtkVolumeRayCastMapper()
if iso:
mapper.SetVolumeRayCastFunction(isofunc)
if info:
print('Isosurface')
else:
mapper.SetVolumeRayCastFunction(compositeFunction)
#mapper.SetMinimumImageSampleDistance(0.2)
if info:
print('Composite')
if affine == None:
mapper.SetInput(im)
else:
#mapper.SetInput(reslice.GetOutput())
mapper.SetInput(changeFilter.GetOutput())
#Return mid position in world space
#im2=reslice.GetOutput()
#index=im2.FindPoint(vol.shape[0]/2.0,vol.shape[1]/2.0,vol.shape[2]/2.0)
#print 'Image Getpoint ' , im2.GetPoint(index)
volum = vtk.vtkVolume()
volum.SetMapper(mapper)
volum.SetProperty(property)
if info :
print 'Origin', volum.GetOrigin()
print 'Orientation', volum.GetOrientation()
print 'OrientationW', volum.GetOrientationWXYZ()
print 'Position', volum.GetPosition()
print 'Center', volum.GetCenter()
print 'Get XRange', volum.GetXRange()
print 'Get YRange', volum.GetYRange()
print 'Get ZRange', volum.GetZRange()
print 'Volume data type', vol.dtype
return volum
def __init__(self, master):
global _vtk_lib_present
if not _vtk_lib_present:
raise ValueError("no VTK")
# Window creation
tk.Frame.__init__(self, master)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
# Renderer and associated widget
self.im_ref = None
self._renWidget = vtkTkRenderWidget(self)
self._ren = vtk.vtkRenderer()
self._renWidget.GetRenderWindow().AddRenderer(self._ren)
self._renWidget.grid(row=0, column=0, sticky=tk.E+tk.W+tk.N+tk.S)
# Transfer functions and volume display options and properties
self.vtk_im = vtkImageImport()
self.vtk_im.SetDataScalarType(VTK_UNSIGNED_CHAR)
self.im_flipy = vtk.vtkImageFlip()
self.im_flipy.SetFilteredAxis(1)
self.im_flipy.SetInputConnection(self.vtk_im.GetOutputPort());
self.im_flipz = vtk.vtkImageFlip()
self.im_flipz.SetFilteredAxis(2)
self.im_flipz.SetInputConnection(self.im_flipy.GetOutputPort());
self.opaTF = vtk.vtkPiecewiseFunction()
self.colTF = vtk.vtkColorTransferFunction()
self.volProp = vtk.vtkVolumeProperty()
self.volProp.SetColor(self.colTF)
self.volProp.SetScalarOpacity(self.opaTF)
self.volProp.ShadeOn()
self.volProp.SetInterpolationTypeToLinear()
self.compoFun = vtk.vtkVolumeRayCastCompositeFunction()
self.isosfFun = vtk.vtkVolumeRayCastIsosurfaceFunction()
self.isosfFun.SetIsoValue(0)
self.mipFun = vtk.vtkVolumeRayCastMIPFunction()
self.volMap = vtk.vtkVolumeRayCastMapper()
self.volMap.SetVolumeRayCastFunction(self.compoFun)
self.volMap.SetInputConnection(self.im_flipz.GetOutputPort())
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volMap)
self.volume.SetProperty(self.volProp)
self.outlineData = vtk.vtkOutlineFilter()
self.outlineData.SetInputConnection(self.im_flipz.GetOutputPort())
self.mapOutline = vtk.vtkPolyDataMapper()
self.mapOutline.SetInputConnection(self.outlineData.GetOutputPort())
self.outline = vtk.vtkActor()
self.outline.SetMapper(self.mapOutline)
self.outline.GetProperty().SetColor(1, 1, 1)
self._ren.AddVolume(self.volume)
self._ren.AddActor(self.outline)
self._ren.SetBackground(116/255.0,214/255.0,220/255.0)
# Control widget
self.controlbar = ttk.Frame(self)
self.controlbar.grid(row=0, column=1,
sticky=tk.E+tk.W+tk.N+tk.S)
self.drawControlBar()
self.controlbar.grid_remove()
self.controlbar.state = "hidden"
self.master = master
# Creates the info status bar.
statusbar = ttk.Frame(self)
statusbar.columnconfigure(0, weight=1)
statusbar.grid(row=1, column=0, columnspan=2, sticky=tk.E+tk.W)
self.infos = []
for i in range(3):
v = tk.StringVar(self)
ttk.Label(statusbar, anchor=tk.W, textvariable=v).grid(row=0, column=i, sticky=tk.E+tk.W)
self.infos.append(v)
self.infos[2].set("Hit Tab for control <-")
# Events bindings
master.bind("<KeyPress-Tab>", self.displayControlEvent)
def initialise(self):
dataImporter = vtk.vtkImageImport()
data_string = self.data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, self.data_matrix.shape[0]-1,
0, self.data_matrix.shape[1]-1,
0, self.data_matrix.shape[2]-1)
dataImporter.SetWholeExtent(0, self.data_matrix.shape[0]-1,
0, self.data_matrix.shape[1]-1,
0, self.data_matrix.shape[2]-1)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
colorFunc = vtk.vtkColorTransferFunction()
for i in range(int(self.data_min),int(self.data_max)):
alphaChannelFunc.AddPoint(i, i/self.data_max )
colorFunc.AddRGBPoint(i,i/self.data_max,i/self.data_max,i/self.data_max)
# for our test sample, we set the black opacity to 0 (transparent) so as
#to see the sample
alphaChannelFunc.AddPoint(0, 0.0)
colorFunc.AddRGBPoint(0,0,0,0)
# alphaChannelFunc = vtk.vtkPiecewiseFunction()
# alphaChannelFunc.AddPoint(self.data_min, 0.0)
# alphaChannelFunc.AddPoint(self.data_max - self.data_min /2, 0.1)
# alphaChannelFunc.AddPoint(self.data_max, 0.2)
#
# # 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(50, 1.0, 0.0, 0.0)
# colorFunc.AddRGBPoint(100, 0.0, 1.0, 0.0)
# colorFunc.AddRGBPoint(150, 0.0, 0.0, 1.0)
# The preavius 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)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# The class vtkVolume is used to pair the preaviusly declared volume as well as the properties to be used when rendering that volume.
self.volume = vtk.vtkVolume()
self.volume.SetMapper(volumeMapper)
self.volume.SetProperty(volumeProperty)
funcOpacityGradient.AddPoint(hi, 1.0) propVolume = vtk.vtkVolumeProperty() propVolume.ShadeOff() propVolume.SetColor(funcColor2) propVolume.SetScalarOpacity(funcOpacityScalar2) propVolume.SetGradientOpacity(funcOpacityGradient) propVolume.SetInterpolationTypeToLinear() ####################################################### funcRayCast = vtk.vtkVolumeRayCastCompositeFunction() funcRayCast.SetCompositeMethodToClassifyFirst() mapperVolume = vtk.vtkVolumeRayCastMapper() #mapperVolume2 = vtk.vtkSmartVolumeMapper()#vtk.vtkFixedPointVolumeRayCastMapper() mapperVolume.SetVolumeRayCastFunction(funcRayCast) mapperVolume.SetInputData(trans.GetOutput())#dataImporter.GetOutput())#imdataBrainSeg) #mapperVolume.SetInputData(dataImporter.GetOutput())#imdataBrainSeg) #mapperVolume2.SetVolumeRayCastFunction(funcRayCast) #mapperVolume2.SetInputData(dataImporter.GetOutput()) actorVolume = vtk.vtkVolume() actorVolume.SetMapper(mapperVolume) actorVolume.SetProperty(propVolume) renderer = createDummyRenderer() renderer.AddActor(actorVolume)
def updateMethod(self):
"""
Set the Rendering method used
"""
self.parameters["QualityValue"] = 0
if not self.initDone:
return
method = self.parameters["Method"]
self.volumeProperty.SetScalarOpacity(self.otfs[method])
self.updateOpacityTransferFunction()
tbl = [
"Ray cast", "Texture Map", "3D texture map", "MIP", "Isosurface"
]
Logging.info("Volume rendering method: ", tbl[method], kw="rendering")
#Ray Casting, RGBA Ray Casting, Texture Mapping, MIP
composites = [
vtk.vtkVolumeRayCastCompositeFunction, None, None,
vtk.vtkVolumeRayCastMIPFunction,
vtk.vtkVolumeRayCastIsosurfaceFunction
]
blendModes = [
"Composite", "Composite", "Composite", "MaximumIntensity",
"Composite"
]
if method in [RAYCAST, MIP, ISOSURFACE]:
# Iso surfacing with fixedpoint mapper is not supported
if method != ISOSURFACE:
self.mapper = vtk.vtkFixedPointVolumeRayCastMapper()
#self.mapper.SetAutoAdjustSampleDistances(1)
self.sampleDistance = self.mapper.GetSampleDistance()
#self.volumeProperty.IndependentComponentsOff()
mode = blendModes[method]
Logging.info("Setting fixed point rendering mode to ",
mode,
kw="rendering")
eval("self.mapper.SetBlendModeTo%s()" % mode)
else:
self.mapper = vtk.vtkVolumeRayCastMapper()
self.function = composites[method]()
Logging.info("Using ray cast function ",
self.function,
kw="rendering")
self.mapper.SetVolumeRayCastFunction(self.function)
elif method == TEXTURE_MAPPING_3D: # 3d texture mapping
self.mapper = vtk.vtkVolumeTextureMapper3D()
self.sampleDistance = self.mapper.GetSampleDistance()
elif method == TEXTURE_MAPPING: # texture mapping
self.mapper = vtk.vtkVolumeTextureMapper2D()
self.maxPlanes = self.mapper.GetMaximumNumberOfPlanes()
# changed following because seems like a mistake, 19.7.2007 SS
# if self.haveVolpro and self.method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]:
if self.haveVolpro and method in [
RAYCAST, ISOSURFACE, MIP
] and self.parameters["UseVolumepro"]:
# use volumepro accelerated rendering
self.mapper = vtk.vtkVolumeProMapper()
modes = [
"Composite", None, None, "MaximumIntensity", "MinimumIntensity"
]
acc = modes[method]
cmd = "self.mapper.SetBlendModeTo%s()" % acc
Logging.info("Setting blending mode to ", acc, kw="rendering")
eval(cmd)
Logging.info("Setting parallel projetion", kw="rendering")
self.renderer.GetActiveCamera().ParallelProjectionOn()
#self.settingEdit.Enable(0)
#self.qualitySlider.Enable(0)
else:
self.renderer.GetActiveCamera().ParallelProjectionOff()
self.mapperUpdated = True
def addVolumeToRenderer(self,img):
pix_diag = 5.0
self.compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
self.compositeFunction.SetCompositeMethodToInterpolateFirst()
self.vtkWidget.Render()
self.volMapper = vtk.vtkVolumeRayCastMapper()
self.window.Render()
self.extensions = vtk.vtkOpenGLExtensionManager()
self.extensions.SetRenderWindow(self.window)
self.extensions.Update()
string = self.extensions.GetExtensionsString()
print(self.extensions.GetExtensionsString())
self.volMapper.SetVolumeRayCastFunction(self.compositeFunction)
self.volMapper.SetSampleDistance(pix_diag / 5.0)
self.volMapper.SetInputConnection(img.GetOutputPort())
self.updateColourTransferFunction()
self.updateOpacityTransferFunction()
self.plane = vtk.vtkPlanes()
def ClipVolumeRender(obj, event):
obj.GetPlanes(self.plane)
self.volMapper.SetClippingPlanes(self.plane)
self.boxWidget = vtk.vtkBoxWidget()
self.boxWidget.SetInteractor(self.vtkWidget)
self.boxWidget.SetPlaceFactor(1.0)
self.boxWidget.SetInput(img.GetOutput())
self.boxWidget.PlaceWidget()
self.boxWidget.InsideOutOn()
self.boxWidget.AddObserver("InteractionEvent", ClipVolumeRender)
self.outlineProperty = self.boxWidget.GetOutlineProperty()
self.outlineProperty.SetRepresentationToWireframe()
self.outlineProperty.SetAmbient(1.0)
self.outlineProperty.SetAmbientColor(0, 0, 0)
self.outlineProperty.SetLineWidth(3)
self.selectedOutlineProperty = self.boxWidget.GetSelectedOutlineProperty()
self.selectedOutlineProperty.SetRepresentationToWireframe()
self.selectedOutlineProperty.SetAmbient(1.0)
self.selectedOutlineProperty.SetAmbientColor(1, 0, 0)
self.selectedOutlineProperty.SetLineWidth(3)
self.outline = vtk.vtkOutlineFilter()
self.outline.SetInputConnection(img.GetOutputPort())
self.outlineMapper = vtk.vtkPolyDataMapper()
self.outlineMapper.SetInputConnection(self.outline.GetOutputPort())
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(self.outlineMapper)
self.vol = vtk.vtkVolume()
self.vol.SetMapper(self.volMapper)
self.vol.SetProperty(self.vtkWidget.volProperty)
self.ren.AddVolume(self.vol)
self.ren.AddActor(self.outlineActor)
self.window.Render()
def WriteImageToDisk(self, filename):
"""Writes thumbnail to disk"""
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
ren.SetBackground(1.0, 1.0, 1.0)
renWin.SetSize(200, 200)
renWin.OffScreenRenderingOn()
# determine image range
self._image.Update()
r = self._image.GetScalarRange()
t = self._threshold
# determine image spacing
sp = self._image.GetSpacing()
# cast image to unsigned char
typ = self._image.GetScalarType()
if ((typ != 3) or (typ != 5)):
cast = vtk.vtkImageShiftScale()
cast.SetInput(self._image)
cast.SetOutputScalarTypeToUnsignedChar()
cast.SetShift(-r[0])
if r[1] == r[0]:
cast.SetScale(255.0 / (r[1] - r[0] + 1))
t = (self._threshold - r[0]) * (255.0 / (r[1] - r[0] + 1))
else:
cast.SetScale(255.0 / (r[1] - r[0]))
t = (self._threshold - r[0]) * (255.0 / (r[1] - r[0]))
r = [0, 255.0]
o = cast.GetOutput()
else:
o = self._image.GetOutput()
# build a LUT
tfun = vtk.vtkPiecewiseFunction()
tfun.AddPoint(r[0], 0.0)
tfun.AddPoint(t - (r[1] - r[0]) / 1024., 0.0)
tfun.AddPoint(t, 0.2)
tfun.AddPoint(r[1], 0.2)
ctfun = vtk.vtkColorTransferFunction()
ctfun.AddRGBPoint(r[0], 1, 1, 1)
ctfun.AddRGBPoint(r[1], 1, 1, 1)
function = vtk.vtkVolumeRayCastIsosurfaceFunction() # tunable
function.SetIsoValue(t)
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetInput(o)
volumeMapper.SetVolumeRayCastFunction(function)
volumeMapper.SetSampleDistance(max(sp) * 1.0) # tunable
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(ctfun)
volumeProperty.SetScalarOpacity(tfun)
volumeProperty.SetInterpolationTypeToLinear() # tunable
volumeProperty.ShadeOn()
newvol = vtk.vtkVolume()
newvol.SetMapper(volumeMapper)
newvol.SetProperty(volumeProperty)
# Add volume to renderer
ren.AddVolume(newvol)
# set up inital camera
camera = ren.GetActiveCamera()
camera.Elevation(-60.0)
camera.SetViewAngle(20)
# grab image
renWin.Render()
windowToimage = vtk.vtkWindowToImageFilter()
windowToimage.SetInput(renWin)
# save image
writer = vtk.vtkJPEGWriter()
writer.SetInput(windowToimage.GetOutput())
writer.SetFileName(filename)
writer.SetQuality(85)
writer.Write()
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.SetSize(600,300)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren1.SetBackground(0.1,0.2,0.4)
i = 0
while i < 2:
j = 0
while j < 4:
locals()[get_variable_name("volumeMapper_", i, "_", j, "")] = vtk.vtkVolumeRayCastMapper()
locals()[get_variable_name("volumeMapper_", i, "_", j, "")].SetInputConnection(reader.GetOutputPort())
locals()[get_variable_name("volumeMapper_", i, "_", j, "")].SetVolumeRayCastFunction(compositeFunction)
locals()[get_variable_name("volumeMapper_", i, "_", j, "")].SetSampleDistance(0.4)
locals()[get_variable_name("volumeMapper_", i, "_", j, "")].CroppingOn()
locals()[get_variable_name("volumeMapper_", i, "_", j, "")].SetCroppingRegionPlanes(17,33,17,33,17,33)
locals()[get_variable_name("volume_", i, "_", j, "")] = vtk.vtkVolume()
locals()[get_variable_name("volume_", i, "_", j, "")].SetMapper(locals()[get_variable_name("volumeMapper_", i, "_", j, "")])
locals()[get_variable_name("volume_", i, "_", j, "")].SetProperty(volumeProperty)
locals()[get_variable_name("userMatrix_", i, "_", j, "")] = vtk.vtkTransform()
locals()[get_variable_name("userMatrix_", i, "_", j, "")].PostMultiply()
locals()[get_variable_name("userMatrix_", i, "_", j, "")].Identity()
locals()[get_variable_name("userMatrix_", i, "_", j, "")].Translate(-25,-25,-25)
if (i == 0):
locals()[get_variable_name("userMatrix_", i, "_", j, "")].RotateX(expr.expr(globals(), locals(),["j","*","87","+","23"]))
locals()[get_variable_name("userMatrix_", i, "_", j, "")].RotateY(16)
# Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddHSVPoint(0.0, 0.66, 1.0, 1.0) colorTransferFunction.AddHSVPoint(50.0, 0.33, 1.0, 1.0) colorTransferFunction.AddHSVPoint(100.0, 0.00, 1.0, 1.0) # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() # The mapper / ray cast function know how to render the data compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() # vtkVolumeTextureMapper2D = vtk.volumeMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(readerSS.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) ren1.AddVolume(volume) # ren1 AddActor contourActor ren1.AddActor(boundsActor)
alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(100, 1.0) colorFunc = vtk.vtkPiecewiseFunction() colorFunc.AddPoint(5, 0.3) colorFunc.AddPoint(25, 0.5) colorFunc.AddPoint(125, 0.7) colorFunc.AddPoint(255, 1.0) vp = vtk.vtkVolumeProperty() vp.SetColor(colorFunc) vp.SetScalarOpacity(alphaChannelFunc) cf = vtk.vtkVolumeRayCastMIPFunction() vM = vtk.vtkVolumeRayCastMapper() vM.SetInputConnection(data_importer.GetOutputPort()) vM.SetVolumeRayCastFunction(cf) volume = vtk.vtkVolume() volume.SetMapper(vM) volume.SetProperty(vp) ren = vtk.vtkRenderer() camera1 = ren.GetActiveCamera() #print camera2.GetPosition() #print camera2.GetFocalPoint() #print camera2.GetViewUp() #print camera2.GetViewAngle() #print camera2.GetClippingRange() #print camera2.GetEyeAngle() #(0.0, 0.0, 1.0)
def LoadVolume(self):
proj = prj.Project()
#image = imagedata_utils.to_vtk(n_array, spacing, slice_number, orientation)
if not self.loaded_image:
self.LoadImage()
self.loaded_image = 1
image = self.image
number_filters = len(self.config['convolutionFilters'])
if (prj.Project().original_orientation == const.AXIAL):
flip_image = True
else:
flip_image = False
#if (flip_image):
update_progress= vtk_utils.ShowProgress(2 + number_filters)
# Flip original vtkImageData
flip = vtk.vtkImageFlip()
flip.SetInputData(image)
flip.SetFilteredAxis(1)
flip.FlipAboutOriginOn()
# flip.ReleaseDataFlagOn()
flip_ref = weakref.ref(flip)
flip_ref().AddObserver("ProgressEvent", lambda obj,evt:
update_progress(flip_ref(), "Rendering..."))
flip.Update()
image = flip.GetOutput()
scale = image.GetScalarRange()
self.scale = scale
cast = vtk.vtkImageShiftScale()
cast.SetInputData(image)
cast.SetShift(abs(scale[0]))
cast.SetOutputScalarTypeToUnsignedShort()
# cast.ReleaseDataFlagOn()
cast_ref = weakref.ref(cast)
cast_ref().AddObserver("ProgressEvent", lambda obj,evt:
update_progress(cast_ref(), "Rendering..."))
cast.Update()
image2 = cast
self.imagedata = image2
if self.config['advancedCLUT']:
self.Create16bColorTable(scale)
self.CreateOpacityTable(scale)
else:
self.Create8bColorTable(scale)
self.Create8bOpacityTable(scale)
image2 = self.ApplyConvolution(image2.GetOutput(), update_progress)
self.final_imagedata = image2
# Changed the vtkVolumeRayCast to vtkFixedPointVolumeRayCastMapper
# because it's faster and the image is better
# TODO: To test if it's true.
if const.TYPE_RAYCASTING_MAPPER:
volume_mapper = vtk.vtkVolumeRayCastMapper()
#volume_mapper.AutoAdjustSampleDistancesOff()
#volume_mapper.SetInput(image2)
#volume_mapper.SetVolumeRayCastFunction(composite_function)
#volume_mapper.SetGradientEstimator(gradientEstimator)
volume_mapper.IntermixIntersectingGeometryOn()
self.volume_mapper = volume_mapper
else:
if int(ses.Session().rendering) == 0:
volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
#volume_mapper.AutoAdjustSampleDistancesOff()
self.volume_mapper = volume_mapper
volume_mapper.IntermixIntersectingGeometryOn()
else:
volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
self.volume_mapper = volume_mapper
self.SetTypeRaycasting()
volume_mapper.SetInputData(image2)
# TODO: Look to this
#volume_mapper_hw = vtk.vtkVolumeTextureMapper3D()
#volume_mapper_hw.SetInput(image2)
#Cut Plane
#CutPlane(image2, volume_mapper)
#self.color_transfer = color_transfer
volume_properties = vtk.vtkVolumeProperty()
#volume_properties.IndependentComponentsOn()
volume_properties.SetInterpolationTypeToLinear()
volume_properties.SetColor(self.color_transfer)
try:
volume_properties.SetScalarOpacity(self.opacity_transfer_func)
except NameError:
pass
# Using these lines to improve the raycasting quality. These values
# seems related to the distance from ray from raycasting.
# TODO: Need to see values that improve the quality and don't decrease
# the performance. 2.0 seems to be a good value to pix_diag
pix_diag = 2.0
volume_mapper.SetImageSampleDistance(0.25)
volume_mapper.SetSampleDistance(pix_diag / 5.0)
volume_properties.SetScalarOpacityUnitDistance(pix_diag)
self.volume_properties = volume_properties
self.SetShading()
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_properties)
self.volume = volume
colour = self.GetBackgroundColour()
self.exist = 1
Publisher.sendMessage('Load volume into viewer',
(volume, colour, (self.ww, self.wl)))
del flip
del cast
def VolumeRenderingRayCast(inVolume, scale=[1, 1, 1], lowerThreshold=0, upperThreshold=None):
"""
Recieve a numpy volume and render it with RayCast method. This method employs CPU raycast
and will subject to upgrades of using GPUVolumeMapper in the future. The method returns
a vtkVolume actor which can be added to a vtkRenderer
:param inVolume: numpy volume
:param scale: scale [x, y, z] of the slice/voxel spacing to real spacing
:param lowerThreshold: lower Threshold for raycast. Default = 0
:param upperThreshold: upper Threshold for raycast. Default = inVolume.max()
:return: vtk.vtkVolume
"""
inVolume = np.ushort(inVolume)
inVolumeString = inVolume.tostring()
# Color map related
if upperThreshold == None:
upperThreshold = inVolume.max()
if upperThreshold <= lowerThreshold:
raise ValueError("Upper Threshold must be larger than lower Threshold.")
centerThreshold = (upperThreshold - lowerThreshold) / 2.0 + lowerThreshold
lowerQuardThreshold = (centerThreshold - lowerThreshold) / 2.0 + lowerThreshold
upperQuardThreshold = (upperThreshold - centerThreshold) / 2.0 + centerThreshold
dataImporter = vtk.vtkImageImport()
dataImporter.CopyImportVoidPointer(inVolumeString, len(inVolumeString))
dataImporter.SetDataScalarTypeToUnsignedShort()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, inVolume.shape[2] - 1, 0, inVolume.shape[1] - 1, 0, inVolume.shape[0] - 1)
dataImporter.SetWholeExtent(0, inVolume.shape[2] - 1, 0, inVolume.shape[1] - 1, 0, inVolume.shape[0] - 1)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(lowerThreshold, 0)
alphaChannelFunc.AddPoint(lowerQuardThreshold, 0.05)
alphaChannelFunc.AddPoint(centerThreshold, 0.4)
alphaChannelFunc.AddPoint(upperQuardThreshold, 0.05)
alphaChannelFunc.AddPoint(upperThreshold, 0)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(lowerThreshold, 0, 0, 0)
colorFunc.AddRGBPoint(centerThreshold, 0.5, 0.5, 0.5)
colorFunc.AddRGBPoint(upperThreshold, 0.8, 0.8, 0.8)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.SetScale(scale)
# Volume is returned for further rendering
return volume
colorTransferFunction.AddRGBSegment(60,1,1,1,90,0,0,0) colorTransferFunction.AddHSVSegment(90,1,1,1,105,0,0,0) colorTransferFunction.AddHSVSegment(40,1,1,1,155,0,0,0) colorTransferFunction.AddHSVSegment(30,1,1,1,95,0,0,0) colorTransferFunction.RemoveAllPoints() colorTransferFunction.AddHSVPoint(0.0,0.01,1.0,1.0) colorTransferFunction.AddHSVPoint(127.5,0.50,1.0,1.0) colorTransferFunction.AddHSVPoint(255.0,0.99,1.0,1.0) colorTransferFunction.SetColorSpaceToHSV() # Create properties, mappers, volume actors, and ray cast function volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.SetInterpolationTypeToLinear() compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) volumeMapper.SetVolumeRayCastFunction(compositeFunction) volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # Create geometric sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(25,25,25) sphereSource.SetRadius(30) sphereSource.SetThetaResolution(15) sphereSource.SetPhiResolution(15) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper)
def testVolumePicker(self):
# volume render a medical data set
# renderer and interactor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
# read the volume
v16 = vtk.vtkVolume16Reader()
v16.SetDataDimensions(64, 64)
v16.SetImageRange(1, 93)
v16.SetDataByteOrderToLittleEndian()
v16.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter")
v16.SetDataSpacing(3.2, 3.2, 1.5)
#---------------------------------------------------------
# set up the volume rendering
rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetInputConnection(v16.GetOutputPort())
volumeMapper.SetVolumeRayCastFunction(rayCastFunction)
volumeColor = vtk.vtkColorTransferFunction()
volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0)
volumeColor.AddRGBPoint(180, 0.3, 0.1, 0.2)
volumeColor.AddRGBPoint(1000, 1.0, 0.7, 0.6)
volumeColor.AddRGBPoint(2000, 1.0, 1.0, 0.9)
volumeScalarOpacity = vtk.vtkPiecewiseFunction()
volumeScalarOpacity.AddPoint(0, 0.0)
volumeScalarOpacity.AddPoint(180, 0.0)
volumeScalarOpacity.AddPoint(1000, 0.2)
volumeScalarOpacity.AddPoint(2000, 0.8)
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.6)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.1)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
#---------------------------------------------------------
# Do the surface rendering
boneExtractor = vtk.vtkMarchingCubes()
boneExtractor.SetInputConnection(v16.GetOutputPort())
boneExtractor.SetValue(0, 1150)
boneNormals = vtk.vtkPolyDataNormals()
boneNormals.SetInputConnection(boneExtractor.GetOutputPort())
boneNormals.SetFeatureAngle(60.0)
boneStripper = vtk.vtkStripper()
boneStripper.SetInputConnection(boneNormals.GetOutputPort())
boneMapper = vtk.vtkPolyDataMapper()
boneMapper.SetInputConnection(boneStripper.GetOutputPort())
boneMapper.ScalarVisibilityOff()
boneProperty = vtk.vtkProperty()
boneProperty.SetColor(1.0, 1.0, 0.9)
bone = vtk.vtkActor()
bone.SetMapper(boneMapper)
bone.SetProperty(boneProperty)
#---------------------------------------------------------
# Create an image actor
table = vtk.vtkLookupTable()
table.SetRange(0, 2000)
table.SetRampToLinear()
table.SetValueRange(0, 1)
table.SetHueRange(0, 0)
table.SetSaturationRange(0, 0)
mapToColors = vtk.vtkImageMapToColors()
mapToColors.SetInputConnection(v16.GetOutputPort())
mapToColors.SetLookupTable(table)
imageActor = vtk.vtkImageActor()
imageActor.GetMapper().SetInputConnection(mapToColors.GetOutputPort())
imageActor.SetDisplayExtent(32, 32, 0, 63, 0, 92)
#---------------------------------------------------------
# make a transform and some clipping planes
transform = vtk.vtkTransform()
transform.RotateWXYZ(-20, 0.0, -0.7, 0.7)
volume.SetUserTransform(transform)
bone.SetUserTransform(transform)
imageActor.SetUserTransform(transform)
c = volume.GetCenter()
volumeClip = vtk.vtkPlane()
volumeClip.SetNormal(0, 1, 0)
volumeClip.SetOrigin(c)
boneClip = vtk.vtkPlane()
boneClip.SetNormal(0, 0, 1)
boneClip.SetOrigin(c)
volumeMapper.AddClippingPlane(volumeClip)
boneMapper.AddClippingPlane(boneClip)
#---------------------------------------------------------
ren.AddViewProp(volume)
ren.AddViewProp(bone)
ren.AddViewProp(imageActor)
camera = ren.GetActiveCamera()
camera.SetFocalPoint(c)
camera.SetPosition(c[0] + 500, c[1] - 100, c[2] - 100)
camera.SetViewUp(0, 0, -1)
ren.ResetCameraClippingRange()
renWin.Render()
#---------------------------------------------------------
# the cone should point along the Z axis
coneSource = vtk.vtkConeSource()
coneSource.CappingOn()
coneSource.SetHeight(12)
coneSource.SetRadius(5)
coneSource.SetResolution(31)
coneSource.SetCenter(6, 0, 0)
coneSource.SetDirection(-1, 0, 0)
#---------------------------------------------------------
picker = vtk.vtkVolumePicker()
picker.SetTolerance(1.0e-6)
picker.SetVolumeOpacityIsovalue(0.01)
# This should usually be left alone, but is used here to increase coverage
picker.UseVolumeGradientOpacityOn()
# A function to point an actor along a vector
def PointCone(actor, n):
if n[0] < 0.0:
actor.RotateWXYZ(180, 0, 1, 0)
actor.RotateWXYZ(180, (n[0] - 1.0) * 0.5, n[1] * 0.5, n[2] * 0.5)
else:
actor.RotateWXYZ(180, (n[0] + 1.0) * 0.5, n[1] * 0.5, n[2] * 0.5)
# Pick the actor
picker.Pick(192, 103, 0, ren)
#print picker
p = picker.GetPickPosition()
n = picker.GetPickNormal()
coneActor1 = vtk.vtkActor()
coneActor1.PickableOff()
coneMapper1 = vtk.vtkDataSetMapper()
coneMapper1.SetInputConnection(coneSource.GetOutputPort())
coneActor1.SetMapper(coneMapper1)
coneActor1.GetProperty().SetColor(1, 0, 0)
coneActor1.SetPosition(p)
PointCone(coneActor1, n)
ren.AddViewProp(coneActor1)
# Pick the volume
picker.Pick(90, 180, 0, ren)
p = picker.GetPickPosition()
n = picker.GetPickNormal()
coneActor2 = vtk.vtkActor()
coneActor2.PickableOff()
coneMapper2 = vtk.vtkDataSetMapper()
coneMapper2.SetInputConnection(coneSource.GetOutputPort())
coneActor2.SetMapper(coneMapper2)
coneActor2.GetProperty().SetColor(1, 0, 0)
coneActor2.SetPosition(p)
PointCone(coneActor2, n)
ren.AddViewProp(coneActor2)
# Pick the image
picker.Pick(200, 200, 0, ren)
p = picker.GetPickPosition()
n = picker.GetPickNormal()
coneActor3 = vtk.vtkActor()
coneActor3.PickableOff()
coneMapper3 = vtk.vtkDataSetMapper()
coneMapper3.SetInputConnection(coneSource.GetOutputPort())
coneActor3.SetMapper(coneMapper3)
coneActor3.GetProperty().SetColor(1, 0, 0)
coneActor3.SetPosition(p)
PointCone(coneActor3, n)
ren.AddViewProp(coneActor3)
# Pick a clipping plane
picker.PickClippingPlanesOn()
picker.Pick(145, 160, 0, ren)
p = picker.GetPickPosition()
n = picker.GetPickNormal()
coneActor4 = vtk.vtkActor()
coneActor4.PickableOff()
coneMapper4 = vtk.vtkDataSetMapper()
coneMapper4.SetInputConnection(coneSource.GetOutputPort())
coneActor4.SetMapper(coneMapper4)
coneActor4.GetProperty().SetColor(1, 0, 0)
coneActor4.SetPosition(p)
PointCone(coneActor4, n)
ren.AddViewProp(coneActor4)
ren.ResetCameraClippingRange()
# render and interact with data
renWin.Render()
img_file = "VolumePicker.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def add_volume(w, ren, N=50, c=(0, 1, 0)):
L = max(w.edge_lengths())
shift = w.edge_lengths() / L * 0.5
tmp = numpy.zeros([N, N, N], dtype=float)
for sp in list_species(w):
# for serial in ("MinD_M", "MinDE"):
# sp = ecell4_base.core.Species(serial)
for pid, p in w.list_particles(sp):
pos = p.position() / L - shift
pos = (pos + ecell4_base.core.Real3(0.5, 0.5, 0.5)) * N
tmp[int(pos[2])][int(pos[1])][int(pos[0])] += 1
data_matrix = numpy.zeros([N, N, N], dtype=numpy.uint8)
if tmp.max() > 0:
norm = 255 / tmp.max()
tmp *= norm
for x in range(N):
for y in range(N):
for z in range(N):
data_matrix[x][y][z] = numpy.uint8(tmp[x][y][z])
del tmp
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
(l, m, n) = data_matrix.shape
dataImporter.SetDataExtent(0, l - 1, 0, m - 1, 0, n - 1)
dataImporter.SetWholeExtent(0, l - 1, 0, m - 1, 0, n - 1)
alphaChannelFunc = vtk.vtkPiecewiseFunction()
# alphaChannelFunc.AddPoint(0, 0.0)
# alphaChannelFunc.AddPoint(50, 0.05)
# alphaChannelFunc.AddPoint(100, 0.1)
# alphaChannelFunc.AddPoint(150, 0.2)
# alphaChannelFunc.AddPoint(0, 0.0)
# alphaChannelFunc.AddPoint(1, 0.05)
# alphaChannelFunc.AddPoint(data_matrix.max(), 0.05)
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(1, 0.255 / 255)
alphaChannelFunc.AddPoint(255, 0.255)
colorFunc = vtk.vtkColorTransferFunction()
# colorFunc.AddRGBPoint(50, 1.0, 0.0, 0.0)
# colorFunc.AddRGBPoint(100, 0.0, 1.0, 0.0)
# colorFunc.AddRGBPoint(150, 0.0, 0.0, 1.0)
if data_matrix.max() > 0:
colorFunc.AddRGBPoint(data_matrix.max(), *c)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren.AddVolume(volume)
def LoadVolume(self):
proj = prj.Project()
#image = imagedata_utils.to_vtk(n_array, spacing, slice_number, orientation)
if not self.loaded_image:
self.LoadImage()
self.loaded_image = 1
image = self.image
number_filters = len(self.config['convolutionFilters'])
if (prj.Project().original_orientation == const.AXIAL):
flip_image = True
else:
flip_image = False
#if (flip_image):
update_progress = vtk_utils.ShowProgress(2 + number_filters)
# Flip original vtkImageData
flip = vtk.vtkImageFlip()
flip.SetInputData(image)
flip.SetFilteredAxis(1)
flip.FlipAboutOriginOn()
# flip.ReleaseDataFlagOn()
flip_ref = weakref.ref(flip)
flip_ref().AddObserver(
"ProgressEvent",
lambda obj, evt: update_progress(flip_ref(), "Rendering..."))
flip.Update()
image = flip.GetOutput()
scale = image.GetScalarRange()
self.scale = scale
cast = vtk.vtkImageShiftScale()
cast.SetInputData(image)
cast.SetShift(abs(scale[0]))
cast.SetOutputScalarTypeToUnsignedShort()
# cast.ReleaseDataFlagOn()
cast_ref = weakref.ref(cast)
cast_ref().AddObserver(
"ProgressEvent",
lambda obj, evt: update_progress(cast_ref(), "Rendering..."))
cast.Update()
image2 = cast
self.imagedata = image2
if self.config['advancedCLUT']:
self.Create16bColorTable(scale)
self.CreateOpacityTable(scale)
else:
self.Create8bColorTable(scale)
self.Create8bOpacityTable(scale)
image2 = self.ApplyConvolution(image2.GetOutput(), update_progress)
self.final_imagedata = image2
# Changed the vtkVolumeRayCast to vtkFixedPointVolumeRayCastMapper
# because it's faster and the image is better
# TODO: To test if it's true.
if const.TYPE_RAYCASTING_MAPPER:
volume_mapper = vtk.vtkVolumeRayCastMapper()
#volume_mapper.AutoAdjustSampleDistancesOff()
#volume_mapper.SetInput(image2)
#volume_mapper.SetVolumeRayCastFunction(composite_function)
#volume_mapper.SetGradientEstimator(gradientEstimator)
volume_mapper.IntermixIntersectingGeometryOn()
self.volume_mapper = volume_mapper
else:
if int(ses.Session().rendering) == 0:
volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
#volume_mapper.AutoAdjustSampleDistancesOff()
self.volume_mapper = volume_mapper
volume_mapper.IntermixIntersectingGeometryOn()
else:
volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
volume_mapper.UseJitteringOn()
self.volume_mapper = volume_mapper
self.SetTypeRaycasting()
volume_mapper.SetInputData(image2)
# TODO: Look to this
#volume_mapper_hw = vtk.vtkVolumeTextureMapper3D()
#volume_mapper_hw.SetInput(image2)
#Cut Plane
#CutPlane(image2, volume_mapper)
#self.color_transfer = color_transfer
volume_properties = vtk.vtkVolumeProperty()
#volume_properties.IndependentComponentsOn()
volume_properties.SetInterpolationTypeToLinear()
volume_properties.SetColor(self.color_transfer)
try:
volume_properties.SetScalarOpacity(self.opacity_transfer_func)
except NameError:
pass
if not self.volume_mapper.IsA("vtkGPUVolumeRayCastMapper"):
# Using these lines to improve the raycasting quality. These values
# seems related to the distance from ray from raycasting.
# TODO: Need to see values that improve the quality and don't decrease
# the performance. 2.0 seems to be a good value to pix_diag
pix_diag = 2.0
volume_mapper.SetImageSampleDistance(0.25)
volume_mapper.SetSampleDistance(pix_diag / 5.0)
volume_properties.SetScalarOpacityUnitDistance(pix_diag)
self.volume_properties = volume_properties
self.SetShading()
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_properties)
self.volume = volume
colour = self.GetBackgroundColour()
self.exist = 1
if self.plane:
self.plane.SetVolumeMapper(volume_mapper)
Publisher.sendMessage('Load volume into viewer',
volume=volume,
colour=colour,
ww=self.ww,
wl=self.wl)
del flip
del cast
def createVolumeDict():
global colourDict
# 0 is skin colour
colourDict = {
1.5: [1.5, 0.0, 1.0, 0.0],
1: [1.0, 0.75, 0.0, 0.0],
2: [2.0, 0.65, 0.65, 0.6],
3: [1.0, 0.75, 0.0, 0.0],
4: [4.0, 1.0, 1.0, 0.0],
5: [1.0, 0.75, 0.0, 0.0],
6: [1.0, 0.75, 0.0, 0.0],
7: [7.0, 0.0, 1.0, 0.0],
8: [1.0, 0.75, 0.0, 0.0],
9: [1.0, 0.75, 0.0, 0.0],
10: [10.0, 0.0, 1.0, 1.0],
11: [1.0, 0.75, 0.0, 0.0],
12: [1.0, 0.75, 0.0, 0.0],
13: [13.0, 1.0, 1.0, 1.0],
14: [1.0, 0.75, 0.0, 0.0],
15: [1.0, 0.75, 0.0, 0.0],
}
# [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
global volumeDict
global lut
volumeDict = {}
# opacityTransferFunction = createOpacityTransferFunction([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])
for value, colourArray in colourDict.iteritems():
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(value, colourArray[1], colourArray[2], colourArray[3])
opacityTransferFunction = createOpacityTransferFunction([value])
# Skin
if value == 1.5:
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0)
opacityTransferFunction.AddPoint(1.5, 0.5)
opacityTransferFunction.AddPoint(3, 0)
# for value, colourArray in colourDict.iteritems():
# 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
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
if value == 1.5:
volumeMapper.SetInputConnection(readerSkin.GetOutputPort())
else:
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)
volumeDict[value] = volume
print volumeDict
def render( data, height ):
"""
Assume 3D data array with integer-valued input.
"""
# For VTK to be able to use the data, it must be stored as a
# VTK-image. This can be done by the vtkImageImport-class which
# imports raw data and stores it.
dataImporter = vtk.vtkImageImport()
# The previously created array is converted to a string of chars and imported.
data_string = data.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
# The type of the newly imported data is set to unsigned char (uint8)
dataImporter.SetDataScalarTypeToUnsignedChar()
# Because the data that is imported only contains an intensity
# value (it isnt RGB-coded or someting similar), the importer must
# be told this is the case.
dataImporter.SetNumberOfScalarComponents(1)
# The following two functions describe how the data is stored and
# the dimensions of the array it is stored in. For this simple
# case, all axes are of length 75 and begins with the first
# element. For other data, this is probably not the case. I have
# to admit however, that I honestly dont know the difference
# between SetDataExtent() and SetWholeExtent() although VTK
# complains if not both are used.
nz, ny, nx = data.shape
dataImporter.SetDataExtent(0, nx-1, 0, ny-1, 0, nz-1)
dataImporter.SetWholeExtent(0, nx-1, 0, ny-1, 0, nz-1)
# The following class is used to store transparencyv-values for
# later retrival. In our case, we want the value 0 to be completly
# opaque whereas the three different cubes are given different
# transperancy-values to show how it works.
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(255, 0.0)
# alphaChannelFunc.AddPoint(dataAvg, 0.1)
# alphaChannelFunc.AddPoint(dataMax, 0.2)
# This class stores color data and can create color tables from a
# the intensity values.
lut = vtk.vtkLookupTable()
lut.Build()
lutNum = data.max()
lut.SetNumberOfTableValues(lutNum)
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0, 0, 1.0)
ctf.AddRGBPoint(data.max(), 1.0, 0, 0 )
# Conversion to RGB tuples based on intensity values -- coarsen
# the number of height values to only 256
for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
cc = ctf.GetColor( ss )
lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
# The preavius 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( ctf ) #colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
# This class describes how the volume is rendered (through ray tracing).
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# 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.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
# 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)
#create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
# plane=vtk.vtkPlane()
# plane.SetOrigin(0,100,100)
# plane.SetNormal(1,0,0)
# #create cutter
# cutter=vtk.vtkCutter()
# cutter.SetCutFunction(plane)
# cutter.SetInputConnection(dataImporter.GetOutputPort())
# cutter.Update()
# cutterMapper=vtk.vtkPolyDataMapper()
# cutterMapper.SetInputConnection( cutter.GetOutputPort())
# #create plane actor
# planeActor=vtk.vtkActor()
# planeActor.GetProperty().SetColor(1.0,1,0)
# planeActor.GetProperty().SetLineWidth(2)
# planeActor.SetMapper(cutterMapper)
#create cube actor
# cubeActor=vtk.vtkActor()
# cubeActor.GetProperty().SetColor(0.5,1,0.5)
# cubeActor.GetProperty().SetOpacity(0.5)
# cubeActor.SetMapper(cubeMapper)
# With almost everything else ready, its time to initialize the
# renderer and window, as well as creating a method for exiting
# the application
renderer = vtk.vtkRenderer()
#renderer.AddActor( planeActor )
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
# We add the volume to the renderer ...
renderer.AddVolume(volume)
# ... set background color to white ...
renderer.SetBackground(0,0,0)
# ... and set window size.
renderWin.SetSize(600, 600)
# add a scalar color bar
sb = vtk.vtkScalarBarActor()
sb.SetTitle("Elevation")
# If the orientation is vertical there is a problem.
sb.SetOrientationToHorizontal()
# Vertical is OK.
# sb.SetOrientationToVertical()
sb.SetWidth(0.6)
sb.SetHeight(0.17)
sb.SetPosition(0.1, 0.05)
sb.SetLookupTable(ctf)
sbw = vtk.vtkScalarBarWidget()
sbw.SetInteractor(renderInteractor)
sbw.SetScalarBarActor(sb)
sbw.On()
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
renderWin.AddObserver("AbortCheckEvent", exitCheck)
renderInteractor.Initialize()
# Because nothing will be rendered without any input, we order the
# first render manually before control is handed over to the
# main-loop.
renderWin.Render()
renderInteractor.Start()
# write a PNG image to disk
writer = vtk.vtkPNGWriter()
writer.SetFileName("rbc_stackVTK_height_"+str(height)+".png")
writer.SetInput(dataImporter.GetOutput())
writer.Write()