def volumeRender(img, tf=[],spacing=[1.0,1.0,1.0]):
importer = numpy2VTK(img,spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(),0,0,0,0])
tf.append([img.max(),1,1,1,1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def test():
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName("C:/Users/Asus/Dropbox/2017-18/ScientificCompAndVisualization/Semana2/SS_2017-master/SS_2017-master/data/wind_image.vti")
volume = vtk.vtkVolume()
#mapper = vtk.vtkFixedPointVolumeRayCastMapper()
mapper = vtk.vtkGPUVolumeRayCastMapper()
mapper.SetBlendModeToMinimumIntensity();
mapper.SetSampleDistance(0.1)
mapper.SetAutoAdjustSampleDistances(0)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
# Set connections
mapper.SetInputConnection(reader.GetOutputPort());
volume.SetMapper(mapper)
ren.AddViewProp(volume)
renWin.AddRenderer(ren)
iRen.SetRenderWindow(renWin)
# Define opacity transfer function and color functions
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0.1, 1.0)
opacityTransferFunction.AddPoint(14, 0.5)
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(1.5, 1.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(0.5, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(3.0, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(6.0, 0.0, 1.0, 1.0)
colorTransferFunction.AddRGBPoint(14.0, 0.0, 0.0, 1.0)
# Now set the opacity and the color
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOff()
volumeProperty.SetInterpolationTypeToLinear()
volume.SetProperty(volumeProperty)
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.5, 0.5, 0.5)
renderer.AddVolume(volume)
renderer.ResetCamera()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(500, 500)
renderWindow.Render()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renderWindow)
iren.Start()
def reader(self,filename,r,g,b):
self.reader_src = vtk.vtkNIFTIImageReader()
self.reader_src.SetFileName(filename)
self.vol_map = vtk.vtkGPUVolumeRayCastMapper()
self.vol_map.SetInputConnection(self.reader_src.GetOutputPort())
# transfer functions for color and opacity
self.funColor = vtk.vtkColorTransferFunction()
self.funColor.AddRGBPoint(0, 0., 0., 0.)
self.funColor.AddRGBPoint(1, r, g, b)
# for the T1
if filename == self.filename1:
self.funAlpha = vtk.vtkPiecewiseFunction()
self.funAlpha.AddPoint(0, 0.)
self.funAlpha.AddPoint(256, .003)
# for the masks
else:
self.funAlpha = vtk.vtkPiecewiseFunction()
self.funAlpha.AddPoint(0, 0.)
self.funAlpha.AddPoint(1, 0.00003)
self.volProp = vtk.vtkVolumeProperty()
self.volProp.SetColor(0, self.funColor)
self.volProp.SetScalarOpacity(0, self.funAlpha)
self.volProp.SetInterpolationTypeToLinear()
self.actor = vtk.vtkVolume()
self.actor.SetMapper(self.vol_map)
self.actor.SetProperty(self.volProp)
return self.actor
def create_volume_rendering(self):
opacityfunction=vtk.vtkPiecewiseFunction()
opacityfunction.AddPoint(0,0.0)
opacityfunction.AddPoint(0.1,0.01)
opacityfunction.AddPoint(1,0.02)
opacityfunction.AddPoint(1.5,0.03)
volproperty=vtk.vtkVolumeProperty()
volproperty.SetColor(self.arrowColor)
volproperty.SetScalarOpacity(opacityfunction)
volproperty.ShadeOn()
volproperty.SetInterpolationTypeToLinear()
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.vol_reader.GetOutputPort())
volumeMapper.SetSampleDistance(0.01)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volproperty)
return volume
def read_images(self, filename, r, g, b, t1=0):
# 2 set up the source
self.reader_src = vtk.vtkNIFTIImageReader()
self.reader_src.SetFileName(filename)
# 3 set up the volume mapper
self.vol_map = vtk.vtkGPUVolumeRayCastMapper()
self.vol_map.SetInputConnection(self.reader_src.GetOutputPort())
# 4 transfer functions for color and opacity
self.funColor = vtk.vtkColorTransferFunction()
self.funColor.AddRGBPoint(0, 0., 0., 0.)
self.funColor.AddRGBPoint(1, r, g, b)
# 5 assign also an alpha (opacity) gradient to the values
if t1 == 1:
self.funAlpha = vtk.vtkPiecewiseFunction()
self.funAlpha.AddPoint(0, 0.)
self.funAlpha.AddPoint(256, 0.01)
else:
self.funAlpha = vtk.vtkPiecewiseFunction()
self.funAlpha.AddPoint(0, 0.)
self.funAlpha.AddPoint(0.01, 0.01)
self.volProp = vtk.vtkVolumeProperty()
self.volProp.SetColor(0, self.funColor)
self.volProp.SetScalarOpacity(0, self.funAlpha)
self.volProp.SetInterpolationTypeToLinear()
self.volActor = vtk.vtkVolume()
self.volActor.SetMapper(self.vol_map)
self.volActor.SetProperty(self.volProp)
return self.volActor, self.funAlpha
def __init__(self):
VolumeFactory.VolumeFactory.__init__(self)
#
# Dabble with GPU
#
self._GPUVolumeRayCastMapper = vtk.vtkGPUVolumeRayCastMapper()
def __init__(self, source):
# 3 set up the volume mapper
volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
volume_mapper.SetInputConnection(source.GetOutputPort())
# 4 transfer functions for color and opacity
self.color_transfer = vtk.vtkColorTransferFunction()
self.alpha_transfer = vtk.vtkPiecewiseFunction()
self.c_map_name = 'copper'
self.c_map = cm.get_cmap(self.c_map_name)
self.init_opacity_points()
self.set_color_transfer() # Fill color transfer function
# 6 set up the volume properties
self.volume_properties = vtk.vtkVolumeProperty()
self.volume_properties.SetColor(0, self.color_transfer)
self.volume_properties.SetScalarOpacity(0, self.alpha_transfer)
self.volume_properties.SetInterpolationTypeToLinear()
self.volume_properties.ShadeOn()
self.volume_properties.SetAmbient(1.0)
self.volume_properties.SetDiffuse(0.7)
self.volume_properties.SetSpecular(0.5)
# 7 set up the actor
self.actor = vtk.vtkVolume()
self.actor.SetMapper(volume_mapper)
self.actor.SetProperty(self.volume_properties)
def volumeRender(self, img, tf=[], spacing=[1.0, 1.0, 1.0]):
importer = dicomShow.numpy2VTK(img, spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(), 0, 0, 0, 0])
tf.append([img.max(), 1, 1, 1, 1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
# working on the GPU
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def viz_VisualizeDICOM(self, path):
volume = vtk.vtkVolume()
dc_img_reader = vtk.vtkDICOMImageReader()
dc_img_reader.SetDirectoryName(path)
dc_img_reader.Update()
dc_color_func = vtk.vtkColorTransferFunction()
dc_color_func.AddRGBPoint(-3024, 0.0, 0.0, 0.0)
dc_color_func.AddRGBPoint(-77, 0.55, 0.25, 0.15)
dc_color_func.AddRGBPoint(94, 0.88, 0.60, 0.29)
dc_color_func.AddRGBPoint(179, 1.0, 0.94, 0.95)
dc_color_func.AddRGBPoint(260, 0.62, 0.0, 0.0)
dc_color_func.AddRGBPoint(3071, 0.82, 0.66, 1.0)
dc_alpha_func = vtk.vtkPiecewiseFunction()
dc_alpha_func.AddPoint(-3024, 0.0)
dc_alpha_func.AddPoint(-77, 0.0)
dc_alpha_func.AddPoint(94, 0.29)
dc_alpha_func.AddPoint(179, 0.55)
dc_alpha_func.AddPoint(260, 0.84)
dc_alpha_func.AddPoint(3071, 0.875)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(dc_color_func)
volumeProperty.SetScalarOpacity(dc_alpha_func)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(dc_img_reader.GetOutputPort())
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.__ren.AddVolume(volume)
def load_file(self, fileName):
# Cleanup the last loaded dataset
if self.imageData is not None:
self.renderer.RemoveViewProp(self.volume)
# Read image data
dataReader = DataReader()
imageData = dataReader.get_image_data(fileName)
# Resize the image data
self.imageResizer = DataResizer()
self.imageData = self.imageResizer.ResizeData(imageData,
maximum=28000000)
# Find max and min
self.minimum, self.maximum = self.imageData.GetScalarRange()
self.lowerBound = self.minimum
self.mipMin = self.minimum
self.mipMax = self.maximum
self.volume = vtkVolume()
self.mapper = vtkGPUVolumeRayCastMapper()
self.mapper.SetBlendModeToComposite()
self.mapper.SetInputData(self.imageData)
if self.renderType is None:
self.set_render_type(RenderTypeSimple)
self.renderType = RenderTypeSimple
else:
# this might not be needed
self.set_render_type(self.renderType)
self.volume.SetMapper(self.mapper)
self.renderer.AddViewProp(self.volume)
self.renderer.ResetCamera()
def __init__(self, default = '', color = [1.0, 0.766, 0.336], singleview = True):
# Create the importer and load a volume (gets things warmed up)
self.dataImporter = vtk.vtkImageImport()
if len(default) == 0:
# a dataset's config.yaml will specify the name of the default volume and it'll be included
default = '/Users/cam/data/dSpaceX/latest/nanoparticles_volume/unprocessed_data/shape_representations/Images.0002.nrrd'
self.loadNewVolume(default)
# colors
colors = vtk.vtkNamedColors()
# volume properties
volumeProperty = vtk.vtkVolumeProperty()
alphaChannelFunc = vtk.vtkPiecewiseFunction()
alphaChannelFunc.AddPoint(0, 0.0)
alphaChannelFunc.AddPoint(228, 0.0)
alphaChannelFunc.AddPoint(255, 0.25)
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(0, color[0]/2.0, color[1]/2.0, color[2]/2.0)
colorFunc.AddRGBPoint(255, color[0], color[1], color[2])
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetDiffuse(2.0)
volumeProperty.SetSpecular(1.5)
volumeProperty.SetSpecularPower(15)
# volume
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.dataImporter.GetOutputPort())
self.volume = vtk.vtkVolume()
self.volume.SetMapper(volumeMapper)
self.volume.SetProperty(volumeProperty)
# renderer
self.ren = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.OffScreenRenderingOn() # ***** don't open a window *****
# add volume, set background and size
self.ren.AddVolume(self.volume)
self.ren.SetBackground(colors.GetColor3d("Wheat"))
# camera
self.resetCamera()
self.renWin.SetWindowName('TwistyTurnyNanoparticle')
# screenshot filter
self.w2if = vtk.vtkWindowToImageFilter()
self.w2if.SetInput(self.renWin)
self.w2if.SetInputBufferTypeToRGB()
self.w2if.ReadFrontBufferOff()
def create_volume(self, time_step):
# Get data
npdatauchar = list()
vtk_volume_prop = vtk.vtkVolumeProperty()
vtk_volume_prop.IndependentComponentsOn()
vtk_volume_prop.SetInterpolationTypeToLinear()
for i, volume in enumerate(self.volume_list):
npdatauchar.append(volume.get_data(time_step, 200, 300, 0.5))
vtk_volume_prop.SetColor(i, volume.vtk_color)
vtk_volume_prop.SetScalarOpacity(i, volume.vtk_opacity)
vtk_volume_prop.ShadeOff(i)
npdatamulti = np.concatenate(
[aux[..., np.newaxis] for aux in npdatauchar], axis=3)
axes = self.volume_list[0].get_axes(time_step)
axes_spacing = self.volume_list[0].get_axes_spacing(
time_step, 200, 300, 0.5)
# Normalize spacing. Too small values lead to ghost volumes.
max_sp = max(axes_spacing["x"], axes_spacing["y"], axes_spacing["z"])
# Too big cells turn opaque, too small become transparent.
# max_cell_size normalizes the cell size
max_cell_size = 0.1
norm_factor = max_cell_size / max_sp
axes_spacing["x"] = axes_spacing["x"] * norm_factor
axes_spacing["y"] = axes_spacing["y"] * norm_factor
axes_spacing["z"] = axes_spacing["z"] * norm_factor
# Put data in VTK format
vtk_data_import = vtk.vtkImageImport()
vtk_data_import.SetImportVoidPointer(npdatamulti)
vtk_data_import.SetDataScalarTypeToUnsignedChar()
vtk_data_import.SetNumberOfScalarComponents(len(self.volume_list))
vtk_data_import.SetDataExtent(0, npdatamulti.shape[2] - 1, 0,
npdatamulti.shape[1] - 1, 0,
npdatamulti.shape[0] - 1)
vtk_data_import.SetWholeExtent(0, npdatamulti.shape[2] - 1, 0,
npdatamulti.shape[1] - 1, 0,
npdatamulti.shape[0] - 1)
vtk_data_import.SetDataSpacing(axes_spacing["x"], axes_spacing["y"],
axes_spacing["z"])
# data origin is also changed by the normalization
vtk_data_import.SetDataOrigin(axes["x"][0] * norm_factor,
axes["y"][0] * norm_factor,
axes["z"][0] * norm_factor)
vtk_data_import.Update()
# Create the mapper
vtk_volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
vtk_volume_mapper.SetInputConnection(vtk_data_import.GetOutputPort())
vtk_volume_mapper.Update()
# Add to volume
self.vtk_volume.SetMapper(vtk_volume_mapper)
self.vtk_volume.SetProperty(vtk_volume_prop)
# Set visualization parameters
self.set_render_quality(self.render_quality)
self.set_color_level(self.volume_color_level)
self.set_color_window(self.volume_color_window)
# Add to render
self.renderer.AddVolume(self.vtk_volume)
self.renderer.ResetCamera()
self.interactor.Render()
def __init__(self, volume_data, genren):
self.volume_data = volume_data
self.genren = genren
self.vtk_renderer = vtk.vtkRenderer()
self.vtk_renderer.SetBackground(0.310999694819562063,0.3400015259021897,0.4299992370489052)
self.renWin = vtk.vtkRenderWindow()
self.renWin.SetSize(256,256)
self.renWin.AddRenderer(self.vtk_renderer)
self.renWin.SetWindowName('VTK Renderer')
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
# compute volume center
volume_spacing = np.array(self.volume_data.GetSpacing())
volume_origin = np.array(self.volume_data.GetOrigin())
volume_dimensions = np.array(self.volume_data.GetDimensions())
volume_max = volume_origin+volume_spacing*volume_dimensions
volume_center = 0.5*(volume_origin+volume_max)
volume_diag = volume_max-volume_origin
#offset_scale = 2.25
offset_scale = 2.0
# camera
self.camera = self.vtk_renderer.MakeCamera()
self.camera.SetClippingRange(0.01,offset_scale*2.0*np.linalg.norm(volume_diag))
self.camera.SetPosition(volume_center[0],volume_center[1],volume_center[2]+offset_scale*np.linalg.norm(volume_diag))
self.camera.SetFocalPoint(volume_center[0],volume_center[1],volume_center[2])
self.camera.Elevation(-85)
self.vtk_renderer.SetActiveCamera(self.camera)
# color map, opacity map
self.vtk_color_map = vtk.vtkColorTransferFunction()
for color_val in self.genren.color_tf:
self.vtk_color_map.AddRGBPoint(color_val[0],color_val[1],color_val[2],color_val[3])
vtk_opacity_map = vtk.vtkPiecewiseFunction()
for op_val in self.genren.opacity_tf:
vtk_opacity_map.AddPoint(op_val[0],op_val[1])
# volume properties
self.prop_volume = vtk.vtkVolumeProperty()
self.prop_volume.ShadeOff()
self.prop_volume.SetColor(self.vtk_color_map)
self.prop_volume.SetScalarOpacity(vtk_opacity_map)
self.prop_volume.SetInterpolationTypeToLinear()
# vtk volume render
self.mapperVolume = vtk.vtkSmartVolumeMapper()
self.mapperVolume = vtk.vtkGPUVolumeRayCastMapper()
self.mapperVolume.SetBlendModeToComposite()
self.mapperVolume.SetInputData(self.volume_data)
self.actorVolume = vtk.vtkVolume()
self.actorVolume.SetMapper(self.mapperVolume)
self.actorVolume.SetProperty(self.prop_volume)
self.vtk_renderer.AddActor(self.actorVolume)
self.iren.Initialize()
def _setup_for_gpu_raycasting(self):
"""This doesn't seem to work. After processing is complete,
it stalls on actually rendering the volume. No idea.
"""
self._volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
self._volume_mapper.SetBlendModeToComposite()
#self._volume_mapper.SetBlendModeToMaximumIntensity()
module_utils.setup_vtk_object_progress(self, self._volume_mapper,
'Preparing render.')
def update_mapper(self):
if self._gpu:
mapper = vtk.vtkGPUVolumeRayCastMapper()
else:
mapper = vtk.vtkFixedPointVolumeRayCastMapper()
mapper.SetInputData(self._volume)
mapper.SetBlendModeToComposite()
self._mapper = mapper
def __init__(self):
self.volumecolorTransferFunction = vtk.vtkColorTransferFunction()
self.isocolorTransferFunction = vtk.vtkColorTransferFunction()
self.opacityTransferFunction = vtk.vtkPiecewiseFunction()
self.isocolor = vtk.vtkColorTransferFunction()
self.volumeProperty = vtk.vtkVolumeProperty()
self.volume = vtk.vtkVolume()
self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
self.actor = vtk.vtkActor()
self.isomapperlist = []
def __init__(self):
QtGui.QMainWindow.__init__(self)
# Set up the user interface (.ui) generated by Qt Creator
self.ui = uic.loadUi("./ui/mainwindow.ui", self)
self.vtkWidget = QVTKRenderWindowInteractor(self.ui.centralWidget)
self.ui.verticalLayout.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.renWin = self.vtkWidget.GetRenderWindow()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
volume_filename = get_volume_filename("../data/nucleon.mhd")
tf_filename = get_transfer_function_filename("../transferfuncs/nucleon.tfi")
opacityTransferFunction, colorTransferFunction = load_transfer_function(tf_filename)
plot_tf(opacityTransferFunction, colorTransferFunction)
# Create the reader for the data
reader = vtk.vtkMetaImageReader()
reader.SetFileName(volume_filename)
# store the filenames and vtk reader for later use
self.volume_filename = volume_filename
self.tf_filename = tf_filename
self.reader = reader
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# for vtkGPUVolumeRayCastMapper
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.ren.AddVolume(volume)
self.ren.SetBackground(1, 1, 1)
#self.renWin.SetSize(600, 600)
#self.renWin.Render()
self.iren.Initialize()
#self.iren.Start()
check_gl_version_supported(self.renWin)
self.ui.show()
def viz_visualize(self):
volume = vtk.vtkVolume()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(self.__colorFunc)
volumeProperty.SetScalarOpacity(self.__alphaChannelFunc)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.__dataImporter.GetOutputPort())
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.__ren.AddVolume(volume)
def __init__(self, data_dir, reader):
tfun = vtk.vtkPiecewiseFunction()
tfun.AddPoint(2440.0, 0.0)
tfun.AddPoint(2800.0, 0.85)
ctfun = vtk.vtkColorTransferFunction()
ctfun.AddRGBPoint(0.0, 0.5, 0.0, 0.0)
ctfun.AddRGBPoint(600.0, 1.0, 0.5, 0.5)
ctfun.AddRGBPoint(1280.0, 0.9, 0.2, 0.3)
ctfun.AddRGBPoint(1960.0, 0.81, 0.27, 0.1)
ctfun.AddRGBPoint(4095.0, 0.5, 0.5, 0.5)
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
volumeMapper.SetBlendModeToComposite()
volumeProperty = vtk.vtkVolumeProperty()
#volumeProperty.SetColor(ctfun)
volumeProperty.SetScalarOpacity(tfun)
volumeProperty.SetInterpolationTypeToLinear()
#volumeProperty.ShadeOn()
newvol = vtk.vtkVolume()
newvol.SetMapper(volumeMapper)
newvol.SetProperty(volumeProperty)
# The SetInteractor method is how 3D widgets are associated with the
# render window interactor. Internally, SetInteractor sets up a bunch
# of callbacks using the Command/Observer mechanism (AddObserver()).
boxWidget = vtk.vtkBoxWidget()
#boxWidget.SetInteractor(iren)
boxWidget.SetPlaceFactor(1.0)
# The implicit function vtkPlanes is used in conjunction with the
# volume ray cast mapper to limit which portion of the volume is
# volume rendered.
planes = vtk.vtkPlanes()
self.planes = planes
def ClipVolumeRender(obj, event):
#global self.planes, volumeMapper
obj.GetPlanes(self.planes)
volumeMapper.SetClippingPlanes(self.planes)
# Place the interactor initially. The output of the reader is used to
# place the box widget.
boxWidget.SetInputConnection(reader.GetOutputPort())
boxWidget.PlaceWidget()
boxWidget.InsideOutOn()
boxWidget.AddObserver("InteractionEvent", ClipVolumeRender)
self.boxWidget = boxWidget
def VolumeRender(img, tf=[], spacing=[1.0, 1.0, 1.0]):
importer = numpy2VTK(img, spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(), 0, 0, 0, 0])
tf.append([img.max(), 1, 1, 1, 1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
# working on the GPU
volMapper = vtk.vtkGPUVolumeRayCastMapper()
volMapper.SetInputConnection(importer.GetOutputPort())
# # The property describes how the data will look
# volProperty = vtk.vtkVolumeProperty()
# volProperty.SetColor(color_tf)
# volProperty.SetScalarOpacity(opacity_tf)
# volProperty.ShadeOn()
# volProperty.SetInterpolationTypeToLinear()
# # working on the CPU
# #volMapper = vtk.vtkVolumeRayCastMapper()
# volMapper = vtkFixedPointVolumeRayCastMapper()
# #compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# #compositeFunction.SetCompositeMethodToInterpolateFirst()
# #volMapper.SetVolumeRayCastFunction(compositeFunction)
# volMapper.SetInputConnection(importer.GetOutputPort())
# The property describes how the data will look
volProperty = vtk.vtkVolumeProperty()
volProperty.SetColor(color_tf)
volProperty.SetScalarOpacity(opacity_tf)
# volProperty.ShadeOn()
volProperty.SetInterpolationTypeToLinear()
# Do the lines below speed things up?
pix_diag = 5.0
volMapper.SetSampleDistance(pix_diag / 1.0)
volProperty.SetScalarOpacityUnitDistance(pix_diag)
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
return [vol]
def createVolumeRender(File, ScalarList, ColorList, OpacList, PieceList):
#Create the mappers
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(File.GetOutputPort())
volumeMapper.SetBlendModeToComposite()
#Create the color transfer function
volumeCTF = vtk.vtkColorTransferFunction()
volumeCTF.AddRGBPoint(ScalarList[0], ColorList[0][0], ColorList[0][1],
ColorList[0][2])
volumeCTF.AddRGBPoint(ScalarList[1], ColorList[1][0], ColorList[1][1],
ColorList[1][2])
volumeCTF.AddRGBPoint(ScalarList[2], ColorList[2][0], ColorList[2][1],
ColorList[2][2])
volumeCTF.AddRGBPoint(ScalarList[3], ColorList[3][0], ColorList[3][1],
ColorList[3][2])
#Create the piecewise function for opacity function
volumeOTF = vtk.vtkPiecewiseFunction()
volumeOTF.AddPoint(ScalarList[0], OpacList[0])
volumeOTF.AddPoint(ScalarList[1], OpacList[1])
volumeOTF.AddPoint(ScalarList[2], OpacList[2])
volumeOTF.AddPoint(ScalarList[3], OpacList[3])
#Create the piecewise function for internal opacity function
volumeGOTF = vtk.vtkPiecewiseFunction()
volumeGOTF.AddPoint(0, PieceList[0])
volumeGOTF.AddPoint(90, PieceList[1])
volumeGOTF.AddPoint(100, PieceList[2])
#Add all the function and ambient, diffuse and specular to the volume property
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(volumeCTF)
volumeProperty.SetScalarOpacity(volumeOTF)
volumeProperty.SetGradientOpacity(volumeGOTF)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.5)
volumeProperty.SetDiffuse(0.5)
volumeProperty.SetSpecular(0.5)
#Create volume and set mapper and property to volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
#Return volume
return volume
def __init__(self, reader):
logging.info("begin Init ViewerVR")
self._reader = reader
#init VolumeRayCastMapper
self._volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
self._volumeMapper.SetSampleDistance(self._volumeMapper.GetSampleDistance()/2)
self._volumeMapper.SetBlendModeToComposite()
self._volumeMapper.SetInputConnection(reader.GetOutputPort())
self._volumeColor = vtk.vtkColorTransferFunction()
self._volumeScalarOpacity = vtk.vtkPiecewiseFunction()
self._volumeGradientOpacity = vtk.vtkPiecewiseFunction()
self._volumeProperty = vtk.vtkVolumeProperty()
self._volume = vtk.vtkVolume()
self._render = vtk.vtkRenderer()
logging.info("End Init ViewerVR")
def open_another_volume_and_tf(self, volume_filename, tf_filename): self.ui.setWindowTitle(volume_filename) opacityTransferFunction, colorTransferFunction = load_transfer_function(tf_filename) plot_tf(opacityTransferFunction, colorTransferFunction) # Create the reader for the data reader = vtk.vtkMetaImageReader() reader.SetFileName(volume_filename) # store the filenames and vtk reader for later use self.volume_filename = volume_filename self.tf_filename = tf_filename self.reader = reader # The property describes how the data will look volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorTransferFunction) volumeProperty.SetScalarOpacity(opacityTransferFunction) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() # for vtkGPUVolumeRayCastMapper volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(reader.GetOutputPort()) # The volume holds the mapper and the property and # can be used to position/orient the volume volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.ren = vtk.vtkRenderer() self.ren.AddVolume(volume) self.ren.SetBackground(1, 1, 1) window = self.vtkWidget.GetRenderWindow() collection = window.GetRenderers() item = collection.GetNextItem() while item is not None: window.RemoveRenderer(item) item = collection.GetNextItem() window.AddRenderer(self.ren) window.Render() self.iren.Initialize()
def initWindow(self, path):
self.vcolor = [[0, 0.0, 0.0, 0.0], [500, 0.6, 0.5, 0.3],
[1000, 0.9, 0.9, 0.3], [1150, 1.0, 1.0, 0.9]]
self.vOpacity = [[0, 0], [500, 0.55], [1000, 0.55], [1150, 0.85]]
self.gOpacity = [[0, 0.0], [90, 0.8], [100, 1.0]]
self.source = vtk.vtkDICOMImageReader()
self.source.SetDirectoryName(path)
self.source.Update()
self.volumcolors = vtk.vtkColorTransferFunction()
self.setOpacityColor(self.vcolor)
self.volumScalarOpacity = vtk.vtkPiecewiseFunction()
self.setOpacityValue(self.vOpacity)
self.volumGradientOpacity = vtk.vtkPiecewiseFunction()
self.setGradientOpacity(self.gOpacity)
self.volumMapper = vtk.vtkGPUVolumeRayCastMapper()
self.volumMapper.SetInputConnection(self.source.GetOutputPort())
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.volumcolors)
self.volumeProperty.SetScalarOpacity(self.volumScalarOpacity)
self.volumeProperty.SetGradientOpacity(self.volumGradientOpacity)
self.volumeProperty.SetInterpolationTypeToLinear()
self.volumeProperty.ShadeOn()
self.volumeProperty.SetAmbient(0.4)
self.volumeProperty.SetDiffuse(0.6)
self.volumeProperty.SetSpecular(0.2)
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumMapper)
self.volume.SetProperty(self.volumeProperty)
self.colors = vtk.vtkNamedColors()
self.colors.SetColor("BackGroundcolors", [255, 255, 255, 255])
self.ren.SetBackground(self.colors.GetColor3d("BackGroundcolors"))
self.ren.AddVolume(self.volume)
self.iren.Initialize()
pass
def volumeRender(img, tf=[],spacing=[1.0,1.0,1.0], box=False):
importer = numpy2VTK(img,spacing)
# Transfer Functions
opacity_tf = vtk.vtkPiecewiseFunction()
color_tf = vtk.vtkColorTransferFunction()
if len(tf) == 0:
tf.append([img.min(),0,0,0,0])
tf.append([img.max(),1,1,1,1])
for p in tf:
color_tf.AddRGBPoint(p[0], p[1], p[2], p[3])
opacity_tf.AddPoint(p[0], p[4])
volMapper = vtk.vtkGPUVolumeRayCastMapper()
# compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# compositeFunction.SetCompositeMethodToInterpolateFirst()
# volMapper.SetVolumeRayCastFunction(compositeFunction)
# pix_diag = 5.0
# volMapper.SetSampleDistance(pix_diag / 5.0)
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()
#volProperty.SetScalarOpacityUnitDistance(pix_diag)
vol = vtk.vtkVolume()
vol.SetMapper(volMapper)
vol.SetProperty(volProperty)
if not box:
return [vol]
else:
bbox = outline(importer)
return [vol,bbox]
def createVlume(polyData, colorFunc, alphaChannelFunc, volumGradientOpacity,
spacings, position):
data_matrix = polyData
data_matrix = np.rot90(data_matrix, 1)
data_matrix = data_matrix.astype(np.uint8)
xSize, ySize, zSize = data_matrix.shape
dataImporter = vtk.vtkImageImport()
data_string = data_matrix.tostring()
dataImporter.CopyImportVoidPointer(data_string, len(data_string))
dataImporter.SetDataScalarTypeToUnsignedChar()
dataImporter.SetNumberOfScalarComponents(1)
dataImporter.SetDataExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1)
dataImporter.SetWholeExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1)
dataImporter.SetDataExtentToWholeExtent()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorFunc)
volumeProperty.SetScalarOpacity(alphaChannelFunc)
volumeProperty.SetGradientOpacity(volumGradientOpacity)
volumeProperty.ShadeOn()
volumeProperty.SetAmbient(0.4)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(dataImporter.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
transform = vtk.vtkTransform()
transform.Scale(spacings)
transform.Translate(position)
volume.SetUserTransform(transform)
return volume
def __setup_default_volume_parameters(self, image_reader):
volume_mapper = vtk.vtkGPUVolumeRayCastMapper()
volume_mapper.SetInputConnection(image_reader.GetOutputPort())
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(0, 0.0)
volumeGradientOpacity.AddPoint(90, 0.5)
volumeGradientOpacity.AddPoint(100, 1.0)
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetGradientOpacity(volumeGradientOpacity)
volumeProperty.SetAmbient(0.4)
volumeProperty.SetDiffuse(0.6)
volumeProperty.SetSpecular(0.2)
self.volume.SetMapper(volume_mapper)
self.volume.SetProperty(volumeProperty)
self.__set_colors()
self.__set_scalar_opacity()
self.__set_gradient_opacity()
self.__set_shading()
def __get_volumedata_actor(self):
# Create the reader for the data
reader = vtk.vtkStructuredPointsReader()
file_path = os.path.join(const.RC_FILE_DIR, "ironProt.vtk")
reader.SetFileName(file_path)
# 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)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
# volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetBlendModeToComposite()
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)
return volume
def loadImage(self, image_data):
r = image_data.GetScalarRange()
n = image_data.GetNumberOfScalarComponents()
print(r)
print(n)
# Create transfer mapping scalar value to opacity.
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(0, 0.0)
opacityTransferFunction.AddPoint(255, 1.0)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(10.0, 0.1, 0.1, 0.1)
colorTransferFunction.AddRGBPoint(255.0, 1.0, 1.0, 1.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data.
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputData(image_data)
volumeMapper.SetBlendModeToComposite()
volumeMapper.Update()
# The volume holds the mapper and the property and
# can be used to position/orient the volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.ren.AddVolume(volume)
self.ren.ResetCameraClippingRange()
self.ren.ResetCamera()
self.renWin().Render()
def create_volume_rendering(self):
opacityfunction = vtk.vtkPiecewiseFunction()
opacityfunction.AddPoint(0, 0.0)
opacityfunction.AddPoint(0.1, 0.01)
opacityfunction.AddPoint(1, 0.02)
opacityfunction.AddPoint(1.5, 0.03)
volproperty = vtk.vtkVolumeProperty()
volproperty.SetColor(self.arrowColor)
volproperty.SetScalarOpacity(opacityfunction)
volproperty.ShadeOn()
volproperty.SetInterpolationTypeToLinear()
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(self.vol_reader.GetOutputPort())
volumeMapper.SetSampleDistance(0.01)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volproperty)
return volume
def 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
ctf.AddRGBPoint(0, 0.0, 0.0, 0.0)
ctf.AddRGBPoint(510, 0.4, 0.4, 1.0)
ctf.AddRGBPoint(640, 1.0, 1.0, 1.0)
ctf.AddRGBPoint(range[1], 0.9, 0.1, 0.1)
pf = vtk.vtkPiecewiseFunction()
pf.AddPoint(0, 0.00)
pf.AddPoint(510, 0.00)
pf.AddPoint(640, 0.5)
pf.AddPoint(range[1], 0.4)
volumeProperty.SetScalarOpacity(pf)
volumeProperty.SetColor(ctf)
volumeProperty.SetShade(1)
mapper = vtk.vtkGPUVolumeRayCastMapper()
mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetUseJittering(1)
# Modify the shader to color based on the depth of the translucent voxel
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, # Replace in the fragment shader
"//VTK::Base::Dec", # Source string to replace
True, # before the standard replacements
"//VTK::Base::Dec" # We still want the default
"\n bool l_updateDepth;"
"\n vec3 l_opaqueFragPos;",
False # only do it once i.e. only replace the first match
)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, "//VTK::Base::Init", True, "//VTK::Base::Init\n"
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.vtkGPUVolumeRayCastMapper()
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
compositeFunction.SetCompositeMethodToInterpolateFirst()
#compositeFunction.SetCompositeMethodToClassifyFirst()
#volMapper.SetVolumeRayCastFunction(compositeFunction)
#volMapper.SetSampleDistance(pix_diag / 5.0)
volMapper.SetImageSampleDistance( .5 )
volMapper.SetSampleDistance(1.0)
volMapper.SetInputConnection( img.GetOutputPort() )
volMapper.SetBlendModeToComposite()
# 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 __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.frame = QtWidgets.QFrame()
self.vl = QtWidgets.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.renWin= self.vtkWidget.GetRenderWindow()
self.renWin.AddRenderer(self.ren)
self.iren = self.renWin.GetInteractor()
self.iren.SetRenderWindow(self.renWin)
dicomReader = vtk.vtk.vtkDICOMImageReader()
dicomReader.SetDirectoryName(r'G:\PythonTrainFaile\SE2')#G:\PythonTrainFaile\SE2 F:\sliver_07\segmentation-0.nii
dicomReader.Update()
srange = dicomReader.GetOutput().GetScalarRange()
print(dicomReader.GetOutput().GetDimensions())
min = srange[0]
max = srange[1]
diff = max - min
slope = 4000 / diff
inter = -slope * min
shift = inter / slope
shifter = vtk.vtkImageShiftScale() # 对偏移和比例参数来对图像数据进行操作 数据转换
shifter.SetShift(shift)
shifter.SetScale(slope)
shifter.SetOutputScalarTypeToUnsignedShort()
shifter.SetInputData(dicomReader.GetOutput())
shifter.ReleaseDataFlagOff()
shifter.Update()
print(min, max, slope, inter, shift)
tfun = vtk.vtkPiecewiseFunction() # 梯度不透明度函数
tfun.AddPoint(2000, 0)
tfun.AddPoint(2300.0, 0.3)
tfun.AddPoint(2501.0, 1)
tfun.AddPoint(2600.0, 1)
tfun.AddPoint(2700.0, 1)
tfun.AddPoint(2900.0, 1)
tfun.AddPoint(3024.0, 1)
ctfun = vtk.vtkColorTransferFunction() # 颜色传输函数
ctfun.AddRGBPoint(0.0, 0.5, 0.0, 0.0)
ctfun.AddRGBPoint(600.0, 1.0, 0.5, 0.5)
ctfun.AddRGBPoint(1280.0, 0.9, 0.2, 0.3)
ctfun.AddRGBPoint(1960.0, 0.81, 0.27, 0.1)
ctfun.AddRGBPoint(2200.0, 0.9, 0.2, 0.3)
ctfun.AddRGBPoint(2500.0, 1, 0.5, 0.5)
ctfun.AddRGBPoint(3024.0, 0.5, 0.5, 0.5)
self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
self.volumeMapper.SetInputConnection(shifter.GetOutputPort())
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(ctfun)
volumeProperty.SetScalarOpacity(tfun)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
newvol = vtk.vtkVolume()
newvol.SetMapper(self.volumeMapper)
newvol.SetProperty(volumeProperty)
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(shifter.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# Create an actor
boxWidget = vtk.vtkBoxWidget()
boxWidget.SetInteractor(self.iren)
boxWidget.SetPlaceFactor(1.0)
# Add the actors to the renderer, set the background and size
self.ren.AddActor(outlineActor)
self.ren.AddVolume(newvol)
self.ren.SetBackground(0, 0, 0)
self.renWin.SetSize(600, 600)
self.planes = vtk.vtkPlanes()
boxWidget.PlaceWidget()
boxWidget.InsideOutOn()
boxWidget.AddObserver("StartInteractionEvent", self.StartInteraction)
boxWidget.AddObserver("InteractionEvent", self.ClipVolumeRender)
boxWidget.AddObserver("EndInteractionEvent", self.EndInteraction)
outlineProperty = boxWidget.GetOutlineProperty()
outlineProperty.SetRepresentationToWireframe()
outlineProperty.SetAmbient(1.0)
outlineProperty.SetAmbientColor(1, 1, 1)
outlineProperty.SetLineWidth(9)
selectedOutlineProperty = boxWidget.GetSelectedOutlineProperty()
selectedOutlineProperty.SetRepresentationToWireframe()
selectedOutlineProperty.SetAmbient(1.0)
selectedOutlineProperty.SetAmbientColor(1, 0, 0)
selectedOutlineProperty.SetLineWidth(3)
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
self.renWin.Render()
self.iren.Start()
ctf.AddRGBPoint(0, 0.0, 0.0, 0.0)
ctf.AddRGBPoint(510, 0.4, 0.4, 1.0)
ctf.AddRGBPoint(640, 1.0, 1.0, 1.0)
ctf.AddRGBPoint(range[1], 0.9, 0.1, 0.1)
pf = vtk.vtkPiecewiseFunction()
pf.AddPoint(0, 0.00)
pf.AddPoint(510, 0.00)
pf.AddPoint(640, 0.5)
pf.AddPoint(range[1], 0.4)
volumeProperty.SetScalarOpacity(pf)
volumeProperty.SetColor(ctf)
volumeProperty.SetShade(1)
mapper = vtk.vtkGPUVolumeRayCastMapper()
mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetUseJittering(1)
# Modify the shader to color based on the depth of the translucent voxel
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment, # Replace in the fragment shader
"//VTK::Base::Dec", # Source string to replace
True, # before the standard replacements
"//VTK::Base::Dec" # We still want the default
"\n bool l_updateDepth;"
"\n vec3 l_opaqueFragPos;",
False # only do it once i.e. only replace the first match
)
mapper.AddShaderReplacement(
vtk.vtkShader.Fragment,
def VolumeRenderingGPURayCast(volumereader, scale=None, lowerThreshold=0, upperThreshold=None):
"""
Ray cast function using GPU general for most volume readers.
:param volumereader: vtk file reader for 3D images
:param scale: scale [x, y, z] of the slice/voxel spacing to real.
Default = [ volumereader.GetNIFTIHeader().GetPixDim(i) for i in xrange(3)]
:param lowerThreshold: lower Threshold for raycast. Default = 0
:param upperThreshold: upper Threshold for raycast. Default = volumereader.GetOutput().GetScalarRange()[1]
:return:
Note: This function requires your version of VTK being compiled with the use of
GPU-proprietary libGL.so. The cmake option is OPEN_gl_LIBRARY for VTK 6.3.0. This
is more trickier in Linux and is potentially more unstable. For your reference
this program is entirely build against nVidia-352 Linux driver.
"""
reader = volumereader
reader.Update()
header = reader.GetNIFTIHeader()
# Insert Default value if none provided
if scale == None:
scale = [abs(header.GetPixDim(i)) for i in xrange(3)] # Insert Default value if none provided
if scale == None:
scale = [abs(header.GetPixDim(i)) for i in xrange(3)]
if upperThreshold == None:
upperThreshold = reader.GetOutput().GetScalarRange()[1]
# Error check
if lowerThreshold >= upperThreshold:
raise ValueError("UpperThreshold cannot be smaller than lowerThreshold")
# Set some default color points
centerThreshold = (upperThreshold - lowerThreshold) / 2.0 + lowerThreshold
lowerQuardThreshold = (centerThreshold - lowerThreshold) / 2.0 + lowerThreshold
upperQuardThreshold = (upperThreshold - centerThreshold) / 2.0 + centerThreshold
# Set some default alpha map
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)
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.SetScale(scale)
return volume
def test(self):
dataRoot = vtkGetDataRoot()
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName("" + str(dataRoot) + "/Data/vase_4comp.vti")
volume = vtk.vtkVolume()
#mapper = vtk.vtkFixedPointVolumeRayCastMapper()
mapper = vtk.vtkGPUVolumeRayCastMapper()
mapper.SetSampleDistance(0.1)
mapper.SetAutoAdjustSampleDistances(0)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iRen = vtk.vtkRenderWindowInteractor()
# Set connections
mapper.SetInputConnection(reader.GetOutputPort());
volume.SetMapper(mapper)
ren.AddViewProp(volume)
renWin.AddRenderer(ren)
iRen.SetRenderWindow(renWin)
# Define opacity transfer function and color functions
opacityFunc1 = vtk.vtkPiecewiseFunction()
opacityFunc1.AddPoint(0.0, 0.0);
opacityFunc1.AddPoint(60.0, 0.1);
opacityFunc1.AddPoint(255.0, 0.0);
opacityFunc2 = vtk.vtkPiecewiseFunction()
opacityFunc2.AddPoint(0.0, 0.0);
opacityFunc2.AddPoint(60.0, 0.0);
opacityFunc2.AddPoint(120.0, 0.1);
opacityFunc1.AddPoint(255.0, 0.0);
opacityFunc3 = vtk.vtkPiecewiseFunction()
opacityFunc3.AddPoint(0.0, 0.0);
opacityFunc3.AddPoint(120.0, 0.0);
opacityFunc3.AddPoint(180.0, 0.1);
opacityFunc3.AddPoint(255.0, 0.0);
opacityFunc4 = vtk.vtkPiecewiseFunction()
opacityFunc4.AddPoint(0.0, 0.0);
opacityFunc4.AddPoint(180.0, 0.0);
opacityFunc4.AddPoint(255.0, 0.1);
# Color transfer functions
color1 = vtk.vtkColorTransferFunction()
color1.AddRGBPoint(0.0, 1.0, 0.0, 0.0);
color1.AddRGBPoint(60.0, 1.0, 0.0, 0.0);
color2 = vtk.vtkColorTransferFunction()
color2.AddRGBPoint(60.0, 0.0, 0.0, 1.0);
color2.AddRGBPoint(120.0, 0.0, 0.0, 1.0);
color3 = vtk.vtkColorTransferFunction()
color3.AddRGBPoint(120.0, 0.0, 1.0, 0.0);
color3.AddRGBPoint(180.0, 0.0, 1.0, 0.0);
color4 = vtk.vtkColorTransferFunction()
color4.AddRGBPoint(180.0, 0.0, 0.0, 0.0);
color4.AddRGBPoint(239.0, 0.0, 0.0, 0.0);
# Now set the opacity and the color
volumeProperty = volume.GetProperty()
volumeProperty.SetIndependentComponents(1)
volumeProperty.SetScalarOpacity(0, opacityFunc1)
volumeProperty.SetScalarOpacity(1, opacityFunc2)
volumeProperty.SetScalarOpacity(2, opacityFunc3)
volumeProperty.SetScalarOpacity(3, opacityFunc4)
volumeProperty.SetColor(0, color1)
volumeProperty.SetColor(1, color2)
volumeProperty.SetColor(2, color3)
volumeProperty.SetColor(3, color4)
iRen.Initialize();
ren.SetBackground(0.1,0.4,0.2)
ren.ResetCamera()
renWin.Render()
img_file = "TestGPURayCastIndependentComponent.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10)
vtk.test.Testing.interact()
def VolumeRenderingGPUDICOMLoader(dicomreader):
"""
Recieve a vtkDICOMImageReader and return the volume actor. Reader can be created in
the following manner:
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(path)
reader.SetDataSpacing(3.2,3.2,1.5) # Set slice spacing
reader.SetDataOrigin(0,0,0)
:param dicomreader: vtkDICOMImageReader()
:return: vtkVolume()
"""
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.vtkGPUVolumeRayCastMapper()
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)
#
#
# print "writing"
# ImageWriter(renderer, outFileName="tmp1")
# print "write finish"
# camera = renderer.GetActiveCamera()
# camera.Zoom(1.3)
# camera.Azimuth(40)
# ImageWriter(renderer, camera=camera, outFileName="tmp2", AAFrames=0)
# print "write cam1"
# camera.Zoom(1.3)
# camera.Azimuth(40)
# ImageWriter(renderer, camera=camera, outFileName="tmp3", AAFrames=0)
# print "write cam2"
# camera.Zoom(1.3)
# camera.Azimuth(40)
# ImageWriter(renderer, camera=camera, outFileName="tmp4", AAFrames=0)
# print "write cam3"
# renderer.ResetCameraClippingRange()
# === DEBUG TEST ===
return volume
