def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent",
self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def visualize_stack(stack: np.ndarray,
color=1.,
spacing=1.,
bg='white',
wsize=None,
cam_pos=None,
cam_fp=None):
if bg == 'white':
bg = (1, 1, 1)
elif bg == 'black':
bg = (0, 0, 0)
elif not isinstance(bg, tuple):
raise NotImplementedError('BG color should be white, black or tuple')
if wsize is None:
wsize = (800, 800)
if cam_pos is None:
cam_pos = (2.0, -4.0, 4.0)
if cam_fp is None:
cam_fp = (0.5, 0.5, 0.5)
vol = vtk.vtkVolume()
mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
ctf = vtk.vtkColorTransferFunction()
scalar_opacity = vtk.vtkPiecewiseFunction()
renderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
dims = stack.shape
vtkdata = numpy2vtk(stack, color, spacing)
mapper.SetInputData(vtkdata)
mapper.SetBlendModeToComposite()
mapper.Update()
# Connect mapper to volume actor
vol.SetMapper(mapper)
# Set color from a linear color transfer function
ctf.AddRGBPoint(0, 0, 0, 0)
ctf.AddRGBPoint(1 * color, 0.9 * color, 0.9 * color, 0.9 * color)
# Set opacity from a piecewise function
scalar_opacity.AddPoint(0, 0)
scalar_opacity.AddPoint(0.1 * color, 0)
scalar_opacity.AddPoint(0.25 * color, 0.1)
scalar_opacity.AddPoint(0.5 * color, 0.8)
scalar_opacity.AddPoint(1 * color, 1)
vol.GetProperty().SetColor(ctf)
vol.GetProperty().SetScalarOpacity(scalar_opacity)
vol.GetProperty().SetInterpolationTypeToLinear()
vol.GetProperty().ShadeOn()
vol.GetProperty().SetAmbient(0.6)
vol.GetProperty().SetDiffuse(0.6)
vol.GetProperty().SetSpecular(0.2)
# Update volume actor
vol.Update()
# Connect volume to renderer and set background
renderer.SetBackground(bg[0], bg[1], bg[2])
renderer.AddVolume(vol)
renderer.GetActiveCamera().Azimuth(90)
renderer.GetActiveCamera().SetViewUp(0, 0, 1)
renderer.GetActiveCamera().SetPosition(dims[2] * cam_pos[2] * spacing,
dims[1] * cam_pos[1] * spacing,
dims[0] * cam_pos[0] * spacing)
renderer.GetActiveCamera().SetFocalPoint(dims[2] * cam_fp[2] * spacing,
dims[1] * cam_fp[1] * spacing,
dims[0] * cam_fp[0] * spacing)
# Connect renderer to render window
renWin.AddRenderer(renderer)
renWin.SetSize(wsize[0], wsize[1])
# Connect window to interactor
iren.SetRenderWindow(renWin)
# Set interactor style
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
# Render
renWin.Render()
renWin.GetRenderers().GetFirstRenderer().ResetCamera()
iren.Start()
def __init__(
self,
inputobj=None,
c='RdBu_r',
alpha=(0.0, 0.0, 0.2, 0.4, 0.8, 1.0),
alphaGradient=None,
alphaUnit=1,
mode=0,
shade=False,
spacing=None,
dims=None,
origin=None,
mapper='smart',
):
vtk.vtkVolume.__init__(self)
BaseGrid.__init__(self)
###################
if isinstance(inputobj, str):
if "https://" in inputobj:
from vedo.io import download
inputobj = download(inputobj, verbose=False) # fpath
elif os.path.isfile(inputobj):
pass
else:
inputobj = sorted(glob.glob(inputobj))
###################
if 'gpu' in mapper:
self._mapper = vtk.vtkGPUVolumeRayCastMapper()
elif 'opengl_gpu' in mapper:
self._mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
elif 'smart' in mapper:
self._mapper = vtk.vtkSmartVolumeMapper()
elif 'fixed' in mapper:
self._mapper = vtk.vtkFixedPointVolumeRayCastMapper()
elif isinstance(mapper, vtk.vtkMapper):
self._mapper = mapper
else:
print("Error unknown mapper type", [mapper])
raise RuntimeError()
self.SetMapper(self._mapper)
###################
inputtype = str(type(inputobj))
#colors.printc('Volume inputtype', inputtype)
if inputobj is None:
img = vtk.vtkImageData()
elif utils.isSequence(inputobj):
if isinstance(inputobj[0], str): # scan sequence of BMP files
ima = vtk.vtkImageAppend()
ima.SetAppendAxis(2)
pb = utils.ProgressBar(0, len(inputobj))
for i in pb.range():
f = inputobj[i]
picr = vtk.vtkBMPReader()
picr.SetFileName(f)
picr.Update()
mgf = vtk.vtkImageMagnitude()
mgf.SetInputData(picr.GetOutput())
mgf.Update()
ima.AddInputData(mgf.GetOutput())
pb.print('loading...')
ima.Update()
img = ima.GetOutput()
else:
if "ndarray" not in inputtype:
inputobj = np.array(inputobj)
if len(inputobj.shape) == 1:
varr = numpy_to_vtk(inputobj,
deep=True,
array_type=vtk.VTK_FLOAT)
else:
if len(inputobj.shape) > 2:
inputobj = np.transpose(inputobj, axes=[2, 1, 0])
varr = numpy_to_vtk(inputobj.ravel(order='F'),
deep=True,
array_type=vtk.VTK_FLOAT)
varr.SetName('input_scalars')
img = vtk.vtkImageData()
if dims is not None:
img.SetDimensions(dims)
else:
if len(inputobj.shape) == 1:
colors.printc(
"Error: must set dimensions (dims keyword) in Volume.",
c='r')
raise RuntimeError()
img.SetDimensions(inputobj.shape)
img.GetPointData().SetScalars(varr)
#to convert rgb to numpy
# img_scalar = data.GetPointData().GetScalars()
# dims = data.GetDimensions()
# n_comp = img_scalar.GetNumberOfComponents()
# temp = numpy_support.vtk_to_numpy(img_scalar)
# numpy_data = temp.reshape(dims[1],dims[0],n_comp)
# numpy_data = numpy_data.transpose(0,1,2)
# numpy_data = np.flipud(numpy_data)
elif "ImageData" in inputtype:
img = inputobj
elif isinstance(inputobj, Volume):
img = inputobj.inputdata()
elif "UniformGrid" in inputtype:
img = inputobj
elif hasattr(
inputobj,
"GetOutput"): # passing vtk object, try extract imagdedata
if hasattr(inputobj, "Update"):
inputobj.Update()
img = inputobj.GetOutput()
elif isinstance(inputobj, str):
from vedo.io import loadImageData, download
if "https://" in inputobj:
inputobj = download(inputobj, verbose=False)
img = loadImageData(inputobj)
else:
colors.printc("Volume(): cannot understand input type:\n",
inputtype,
c='r')
return
if dims is not None:
img.SetDimensions(dims)
if origin is not None:
img.SetOrigin(origin) ### DIFFERENT from volume.origin()!
if spacing is not None:
img.SetSpacing(spacing)
self._data = img
self._mapper.SetInputData(img)
self.mode(mode).color(c).alpha(alpha).alphaGradient(alphaGradient)
self.GetProperty().SetShade(True)
self.GetProperty().SetInterpolationType(1)
self.GetProperty().SetScalarOpacityUnitDistance(alphaUnit)
# remember stuff:
self._mode = mode
self._color = c
self._alpha = alpha
self._alphaGrad = alphaGradient
self._alphaUnit = alphaUnit
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.vtkOpenGLGPUVolumeRayCastMapper()
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,
# The previous two classes stored properties and 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()
# set the color for volumes
volumeProperty.SetColor(colorFunc)
# To add black as background of Volume
volumeProperty.SetScalarOpacity(opacity)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetIndependentComponents(2)
#Ray cast function know how to render the data
volumeMapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
#volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
#volumeMapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
volumeMapper.SetBlendModeToMaximumIntensity()
# Different modes are available in vtk for Blend mode functions
#volumeMapper.SetBlendModeToAverageIntensity()
#volumeMapper.SetBlendModeToMinimumIntensity()
#volumeMapper.SetBlendModeToComposite()
#volumeMapper.SetBlendModeToAdditive()
volume = vtk.vtkVolume()
def __init__(self, arr, renderWindow):
self.arr = arr # input volume
self.renderWindow = renderWindow #output render window
from vtk.util import numpy_support as nps
# 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.
fmin,fmax = np.min(arr),np.max(arr)
def nfv(t):
return fmin+t*(fmax - fmin)
scalars = nps.numpy_to_vtk(arr.ravel())
scalars.SetName("Scalars")
imageData = vtk.vtkImageData()
imageData.SetDimensions(arr.shape)
#assume 0,0 origin and 1,1 spacing.
#__depthImageData.SetSpacing([1,1])
#__depthImageData.SetOrigin([0,0])
imageData.GetPointData().SetScalars(scalars)
imageData.SetExtent(0, arr.shape[2]-1, 0, arr.shape[1]-1, 0, arr.shape[0]-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(nfv(0.0) , 0.0)
alphaChannelFunc.AddPoint(nfv(0.2) , 0.01)
alphaChannelFunc.AddPoint(nfv(0.5) , 0.1)
alphaChannelFunc.AddPoint(nfv(1.0) , 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(nfv(0.01) , 0.0, 0.0, 1.0)
colorFunc.AddRGBPoint(nfv(0.5) , 1.0, 1.0, 1.0)
colorFunc.AddRGBPoint(nfv(1.0) , 1.0, 0.0, 0.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.ShadeOn()
volumeProperty.SetScalarOpacity(alphaChannelFunc)
# 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.vtkOpenGLGPUVolumeRayCastMapper()
volumeMapper.SetInputData(imageData) if vtk.VTK_MAJOR_VERSION > 5 else volumeMapper.SetInputConnection(imageData.GetProducerPort())
# 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)
# Add a bounding box around the dataset
bbFilter = vtk.vtkOutlineFilter()
bbFilter.SetInputData(imageData) if vtk.VTK_MAJOR_VERSION > 5 else bbFilter.SetInputConnection(imageData.GetProducerPort())
bbMapper = vtk.vtkDataSetMapper()
bbMapper.SetInputConnection(bbFilter.GetOutputPort())
bbActor = vtk.vtkActor()
bbActor.GetProperty().EdgeVisibilityOn()
bbActor.GetProperty().SetEdgeColor(1,1,1)
bbActor.SetMapper(bbMapper)
# add a renderer to the widget
self.ren = vtk.vtkRenderer()
self.renderWindow.AddRenderer(self.ren)
# add a volume and ResetCamera
self.ren.AddVolume(volume)
self.ren.AddActor(bbActor)
self.ren.ResetCamera()
#prepare interactor
istyle = vtk.vtkInteractorStyleTrackballCamera()
self.iren = self.renderWindow.GetInteractor()
self.iren.SetInteractorStyle(istyle)
self.iren.Initialize()
self.imageData = imageData
self.volumeMapper = volumeMapper
def __init__(
self,
inputobj=None,
c=('b', 'lb', 'lg', 'y', 'r'),
alpha=(0.0, 0.0, 0.2, 0.4, 0.8, 1),
alphaGradient=None,
mode=0,
origin=None,
spacing=None,
shape=None,
mapperType='smart',
):
vtk.vtkVolume.__init__(self)
ActorBase.__init__(self)
inputtype = str(type(inputobj))
#colors.printc('Volume inputtype', inputtype)
if isinstance(inputobj, str):
import glob
inputobj = sorted(glob.glob(inputobj))
if inputobj is None:
img = vtk.vtkImageData()
elif utils.isSequence(inputobj):
if isinstance(inputobj[0], str): # scan sequence of BMP files
ima = vtk.vtkImageAppend()
ima.SetAppendAxis(2)
pb = utils.ProgressBar(0, len(inputobj))
for i in pb.range():
f = inputobj[i]
picr = vtk.vtkBMPReader()
picr.SetFileName(f)
picr.Update()
mgf = vtk.vtkImageMagnitude()
mgf.SetInputData(picr.GetOutput())
mgf.Update()
ima.AddInputData(mgf.GetOutput())
pb.print('loading..')
ima.Update()
img = ima.GetOutput()
else:
if "ndarray" not in inputtype:
inputobj = np.array(inputobj)
varr = numpy_to_vtk(inputobj.ravel(order='F'),
deep=True,
array_type=vtk.VTK_FLOAT)
varr.SetName('input_scalars')
img = vtk.vtkImageData()
if shape is not None:
img.SetDimensions(shape)
else:
img.SetDimensions(inputobj.shape)
img.GetPointData().SetScalars(varr)
#to convert rgb to numpy
# img_scalar = data.GetPointData().GetScalars()
# dims = data.GetDimensions()
# n_comp = img_scalar.GetNumberOfComponents()
# temp = numpy_support.vtk_to_numpy(img_scalar)
# numpy_data = temp.reshape(dims[1],dims[0],n_comp)
# numpy_data = numpy_data.transpose(0,1,2)
# numpy_data = np.flipud(numpy_data)
elif "ImageData" in inputtype:
img = inputobj
elif "UniformGrid" in inputtype:
img = inputobj
elif "UnstructuredGrid" in inputtype:
img = inputobj
mapperType = 'tetra'
elif hasattr(
inputobj,
"GetOutput"): # passing vtk object, try extract imagdedata
if hasattr(inputobj, "Update"):
inputobj.Update()
img = inputobj.GetOutput()
else:
colors.printc("Volume(): cannot understand input type:\n",
inputtype,
c=1)
return
if 'gpu' in mapperType:
self._mapper = vtk.vtkGPUVolumeRayCastMapper()
elif 'opengl_gpu' in mapperType:
self._mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
elif 'smart' in mapperType:
self._mapper = vtk.vtkSmartVolumeMapper()
elif 'fixed' in mapperType:
self._mapper = vtk.vtkFixedPointVolumeRayCastMapper()
elif 'tetra' in mapperType:
self._mapper = vtk.vtkProjectedTetrahedraMapper()
elif 'unstr' in mapperType:
self._mapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
else:
print("Error unknown mapperType", mapperType)
raise RuntimeError()
if origin is not None:
img.SetOrigin(origin)
if spacing is not None:
img.SetSpacing(spacing)
if shape is not None:
img.SetDimensions(shape)
self._imagedata = img
self._mapper.SetInputData(img)
self.SetMapper(self._mapper)
self.mode(mode).color(c).alpha(alpha).alphaGradient(alphaGradient)
self.GetProperty().SetInterpolationType(1)
# remember stuff:
self._mode = mode
self._color = c
self._alpha = alpha
self._alphaGrad = alphaGradient
def vtk_pipeline(vesselmaskpath):
# 1. Source -Reader
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(vesselmaskpath)
reader.Update()
size = reader.GetOutput().GetDimensions()
center = reader.GetOutput().GetCenter()
spacing = reader.GetOutput().GetSpacing()
reader.SetDataSpacing(spacing)
# reader=vtk.vtkTIFFReader()
# # reader=VTK_data
# reader.SetFileNames(filePath)
# reader.SetDataSpacing(0.63867188, 0.63867188, 3)
reader.Update()
print(reader)
# 2. Filter --> Setting the color mapper, Opacity for VolumeProperty
colorFunc = vtk.vtkColorTransferFunction()
colorFunc.AddRGBPoint(1, 1, 0.0, 0.0) # Red
# To set different colored pores
# colorFunc.AddRGBPoint(2, 0.0, 1, 0.0) # Green
#colorFunc.AddRGBPoint(3, 0.0, 0, 1.0) # Black
#colorFunc.AddRGBPoint(4, 0.0, 0.0, 1) # Blue
opacity = vtk.vtkPiecewiseFunction()
# opacity.AddPoint(1, 1, 0.0, 0.0)
# opacity.AddPoint(2, 0.0, 0.0, 0.0)
# The previous two classes stored properties and 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()
# set the color for volumes
volumeProperty.SetColor(colorFunc)
# To add black as background of Volume
volumeProperty.SetScalarOpacity(opacity)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.SetIndependentComponents(2)
#Ray cast function know how to render the data
volumeMapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
# volumeMapper = vtk.vtkSmartVolumeMapper()
# volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
# volumeMapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
volumeMapper.SetBlendModeToMaximumIntensity()
# Different modes are available in vtk for Blend mode functions
#volumeMapper.SetBlendModeToAverageIntensity()
#volumeMapper.SetBlendModeToMinimumIntensity()
#volumeMapper.SetBlendModeToComposite()
#volumeMapper.SetBlendModeToAdditive()
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren = vtk.vtkRenderer()
ren.AddVolume(volume)
#No need to set by default it is black
ren.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(900, 900)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renWin)
interactor.Initialize()
renWin.Render()
interactor.Start()
return
# vtk_pipeline(vesselmaskpath)
def __init__(
self,
inputobj,
c=('b', 'lb', 'lg', 'y', 'r'),
alpha=(0.0, 0.0, 0.2, 0.4, 0.8, 1),
alphaGradient=None,
mode=0,
origin=None,
spacing=None,
shape=None,
mapperType='gpu',
):
vtk.vtkVolume.__init__(self)
ActorBase.__init__(self)
inputtype = str(type(inputobj))
#colors.printc('Volume inputtype', inputtype)
if inputobj is None:
img = vtk.vtkImageData()
elif utils.isSequence(inputobj):
if "ndarray" not in inputtype:
inputobj = np.array(inputobj)
varr = numpy_to_vtk(inputobj.ravel(order='F'),
deep=True,
array_type=vtk.VTK_FLOAT)
varr.SetName('input_scalars')
img = vtk.vtkImageData()
if shape is not None:
img.SetDimensions(shape)
else:
img.SetDimensions(inputobj.shape)
img.GetPointData().SetScalars(varr)
#to convert rgb to numpy
# img_scalar = data.GetPointData().GetScalars()
# dims = data.GetDimensions()
# n_comp = img_scalar.GetNumberOfComponents()
# temp = numpy_support.vtk_to_numpy(img_scalar)
# numpy_data = temp.reshape(dims[1],dims[0],n_comp)
# numpy_data = numpy_data.transpose(0,1,2)
# numpy_data = np.flipud(numpy_data)
elif "ImageData" in inputtype:
img = inputobj
elif "UniformGrid" in inputtype:
img = inputobj
elif "UnstructuredGrid" in inputtype:
img = inputobj
mapperType = 'tetra'
elif hasattr(
inputobj,
"GetOutput"): # passing vtk object, try extract imagdedata
if hasattr(inputobj, "Update"):
inputobj.Update()
img = inputobj.GetOutput()
else:
colors.printc("Volume(): cannot understand input type:\n",
inputtype,
c=1)
return
if 'gpu' in mapperType:
self._mapper = vtk.vtkGPUVolumeRayCastMapper()
elif 'opengl_gpu' in mapperType:
self._mapper = vtk.vtkOpenGLGPUVolumeRayCastMapper()
elif 'smart' in mapperType:
self._mapper = vtk.vtkSmartVolumeMapper()
elif 'fixed' in mapperType:
self._mapper = vtk.vtkFixedPointVolumeRayCastMapper()
elif 'tetra' in mapperType:
self._mapper = vtk.vtkProjectedTetrahedraMapper()
elif 'unstr' in mapperType:
self._mapper = vtk.vtkUnstructuredGridVolumeRayCastMapper()
if origin is not None:
img.SetOrigin(origin)
if spacing is not None:
img.SetSpacing(spacing)
if shape is not None:
img.SetDimensions(shape)
self._imagedata = img
self._mapper.SetInputData(img)
self.SetMapper(self._mapper)
self.mode(mode).color(c).alpha(alpha).alphaGradient(alphaGradient)
# remember stuff:
self._mode = mode
self._color = c
self._alpha = alpha
self._alphaGrad = alphaGradient
def main():
fileName = '/home/tony/Desktop/DV_homework/homework5/pv_insitu_300x300x300_30068.vti'
colors = vtk.vtkNamedColors()
# This is a simple volume rendering example that
# uses a vtkFixedPointVolumeRayCastMapper
# Create the standard renderer, render window
# and interactor.
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the reader for the data.
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileName)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
# Create transfer mapping scalar value to opacity.
opacityTransferFunction = vtk.vtkPiecewiseFunction()
# How to save transfer function from Paraview
# In 'color mapp editor', click the button 'Save to present' (a folder icon with a green arrow)
# A window 'Save present option' will pop out, make sure 'Save opatities' is checked. Then click 'OK'
# A window 'Choose present' will pop out, click 'Export' and set the transfer function to a .json file
# # load transfer function from paraview
# paraview transfer function assume the data range are 0 to 1.
# when you setup the trasnfer function in vtk, you have to rescale it to the data range of the dataset
json_data = open('/home/tony/Desktop/DV_homework/homework5/cool_warm.json')
data = json.load(json_data)
json_data.close()
# pprint(data)
nOpaPoint = int(len(data[0]['Points']) /
4) # number of opacity function control point
for i in range(nOpaPoint):
dtValue = data[0]['Points'][i * 4]
opaValue = data[0]['Points'][i * 4 + 1]
opacityTransferFunction.AddPoint(dtValue, opaValue)
print('opacity control point: ', i, ': ', dtValue, opaValue)
nRgbPoint = int(len(data[0]['RGBPoints']) /
4) # number of the color map control point
for i in range(nRgbPoint):
dtValue = data[0]['RGBPoints'][i * 4]
r = data[0]['RGBPoints'][i * 4 + 1]
g = data[0]['RGBPoints'][i * 4 + 2]
b = data[0]['RGBPoints'][i * 4 + 3]
colorTransferFunction.AddRGBPoint(dtValue, r, g, b)
print('rgb control point: ', i, ': ', dtValue, r, g, b)
# after load the control points from opacity function and color map,
# You can use them to setup you transfer function in VTK
# 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.vtkOpenGLGPUVolumeRayCastMapper()
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)
ren1.AddVolume(volume)
ren1.SetBackground(colors.GetColor3d("Wheat"))
ren1.GetActiveCamera().Azimuth(45)
ren1.GetActiveCamera().Elevation(30)
ren1.ResetCameraClippingRange()
ren1.ResetCamera()
renWin.SetSize(600, 600)
renWin.Render()
iren.Start()
