def rendering(dataPath, label, lowerThreshold, upperThreshold, surface,
dualSurface, volume, dual_volume, sigmoid):
# Read the data
if dataPath.endswith('.nrrd'):
reader = vtk.vtkNrrdReader()
reader.SetFileName(dataPath)
reader.Update()
# if dataPath.endswith('.nii'):
# reader = vtk.vtkNIFTIImageReader()
# reader.SetFileName(dataPath)
# reader.Update()
else:
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(dataPath)
reader.Update()
if label.endswith('.nrrd'):
reader2 = vtk.vtkNrrdReader()
reader2.SetFileName(label)
reader2.Update()
else:
reader2 = vtk.vtkDICOMImageReader()
reader2.SetDirectoryName(label)
reader2.Update()
# if sigmoid.endswith('.nii'):
# reader3 = vtk.vtkNIFTIImageReader()
# reader3.SetFileName(sigmoid)
# reader3.Update()
# else:
# reader3 = vtk.vtkDICOMImageReader()
# reader3.SetDirectoryName(sigmoid)
# reader3.Update()
# Smooth the image
filteredImage = gaussianFilter(reader)
# Surface rendering
if surface:
surfaceRendering(reader2.GetOutput(), lowerThreshold, upperThreshold)
if dualSurface:
dualSurfaceRendering(filteredImage, reader2.GetOutput())
# Volume rendering
if volume:
volumeRendering(reader2.GetOutput(), lowerThreshold, upperThreshold)
if dual_volume:
dual_volumeRendering(reader.GetOutput(), reader2.GetOutput(),
lowerThreshold, upperThreshold,
reader3.GetOutput())
def loadImageData(filename, spacing=()):
"""Read and return a ``vtkImageData`` object from file.
Use ``load`` instead.
E.g. `img = load('myfile.tif').imagedata()`
"""
if ".tif" in filename.lower():
reader = vtk.vtkTIFFReader()
elif ".slc" in filename.lower():
reader = vtk.vtkSLCReader()
if not reader.CanReadFile(filename):
colors.printc("~prohibited Sorry bad slc file " + filename, c=1)
return None
elif ".vti" in filename.lower():
reader = vtk.vtkXMLImageDataReader()
elif ".mhd" in filename.lower():
reader = vtk.vtkMetaImageReader()
elif ".dem" in filename.lower():
reader = vtk.vtkDEMReader()
elif ".nii" in filename.lower():
reader = vtk.vtkNIFTIImageReader()
elif ".nrrd" in filename.lower():
reader = vtk.vtkNrrdReader()
if not reader.CanReadFile(filename):
colors.printc("~prohibited Sorry bad nrrd file " + filename, c=1)
return None
reader.SetFileName(filename)
reader.Update()
image = reader.GetOutput()
if len(spacing) == 3:
image.SetSpacing(spacing[0], spacing[1], spacing[2])
return image
def readnrrd(filename):
"""Read image in nrrd format."""
reader = vtk.vtkNrrdReader()
reader.SetFileName(filename)
reader.Update()
info = reader.GetInformation()
return reader.GetOutput(), info
def main(args):
reader = vtk.vtkNrrdReader()
reader.SetFileName(args.img)
reader.Update()
img = reader.GetOutput()
print(img)
actor = vtk.vtkImageActor()
actor.GetMapper().SetInputData(img)
# Setup rendering
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(1, 1, 1)
renderer.ResetCamera()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetInteractorStyle(vtk.vtkInteractorStyleImage())
renderWindowInteractor.AddObserver("KeyPressEvent", Keypress)
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.Initialize()
renderWindowInteractor.Start()
def get_vtk_reader_from_file_name(file_name):
'''Find a valid vtkImageReader2 for a give file.
If no reader can be found, None is returned. Currently, this
function does not support reading in a DICOM series.
The following readers are registered beyond the standard:
vtkNIFTIImageReader, vtkDICOMImageReader.
Args:
file_name (string): Input file name on disk
Returns:
vtk.vtkImageReader2: The vtkImageReader2
'''
# Add readers which are not registered by default
vtk.vtkImageReader2Factory.RegisterReader(vtk.vtkNIFTIImageReader())
vtk.vtkImageReader2Factory.RegisterReader(vtk.vtkNrrdReader())
# Disable the DICOM reader. It prints too many errors.
# vtk.vtkImageReader2Factory.RegisterReader(vtk.vtkDICOMImageReader())
# Use factory to return the correct reader
reader = vtk.vtkImageReader2Factory.CreateImageReader2(file_name)
return reader
def GetImageDataForBaseAndExtension(self, fileName, extension):
"""
:type fileName: basestring
:type extension: basestring
:rtype: vtkImageData
"""
if extension == DataReader.TypeMHA or extension == DataReader.TypeMHD:
# Use a vktMetaImageReader
imageReader = vtkMetaImageReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
elif extension == DataReader.TypeDICOM:
# Use a dicom reader
dirName = os.path.dirname(fileName)
return self.GetImageDataFromDirectory(dirName)
elif extension == DataReader.TypeDAT:
raise Exception("Support for .dat files is not implemented.")
# Read in the .dat file byte by byte
imageData = None
import numpy as np
with open(fileName, "rb") as f:
dimensions = np.fromfile(f, np.int16, count=3)
imageData = vtkImageData()
imageData.SetDimensions(int(dimensions[0]), int(dimensions[1]),
int(dimensions[2]))
imageData.SetScalarTypeToFloat()
imageData.SetNumberOfScalarComponents(1)
imageData.AllocateScalars()
imageData.Update()
imageData.PrepareForNewData()
fileData = np.fromfile(f, np.int16)
dataIndex = 0
for z in range(int(dimensions[2])):
for y in range(int(dimensions[1])):
for x in range(int(dimensions[0])):
imageData.SetScalarComponentFromFloat(
x, y, z, 0, float(fileData[dataIndex]))
dataIndex += 1
return imageData
elif extension == DataReader.TypeVTI:
# Use a XMLImageReader
imageReader = vtkXMLImageDataReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
elif extension == DataReader.TypeNRRD:
# Use a NrrdReader
imageReader = vtkNrrdReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
else:
assert False
def GetImageDataForBaseAndExtension(self, fileName, extension):
"""
:type fileName: basestring
:type extension: basestring
:rtype: vtkImageData
"""
if extension == DataReader.TypeMHA or extension == DataReader.TypeMHD:
# Use a vktMetaImageReader
imageReader = vtkMetaImageReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
elif extension == DataReader.TypeDICOM:
# Use a dicom reader
dirName = os.path.dirname(fileName)
return self.GetImageDataFromDirectory(dirName)
elif extension == DataReader.TypeDAT:
raise Exception("Support for .dat files is not implemented.")
# Read in the .dat file byte by byte
imageData = None
import numpy as np
with open(fileName, "rb") as f:
dimensions = np.fromfile(f, np.int16, count=3)
imageData = vtkImageData()
imageData.SetDimensions(int(dimensions[0]), int(dimensions[1]), int(dimensions[2]))
imageData.SetScalarTypeToFloat()
imageData.SetNumberOfScalarComponents(1)
imageData.AllocateScalars()
imageData.Update()
imageData.PrepareForNewData()
fileData = np.fromfile(f, np.int16)
dataIndex = 0
for z in range(int(dimensions[2])):
for y in range(int(dimensions[1])):
for x in range(int(dimensions[0])):
imageData.SetScalarComponentFromFloat(x, y, z, 0, float(fileData[dataIndex]))
dataIndex += 1
return imageData
elif extension == DataReader.TypeVTI:
# Use a XMLImageReader
imageReader = vtkXMLImageDataReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
elif extension == DataReader.TypeNRRD:
# Use a NrrdReader
imageReader = vtkNrrdReader()
imageReader.SetFileName(fileName)
imageReader.Update()
return imageReader.GetOutput()
else:
assert False
def main(args):
img_fn_array = []
if args.image:
img_obj = {}
img_obj["img"] = args.image
img_obj["out"] = args.out
img_fn_array.append(img_obj)
elif args.dir:
normpath = os.path.normpath("/".join([args.dir, '**', '*']))
for img_fn in glob.iglob(normpath, recursive=True):
if os.path.isfile(img_fn) and True in [
ext in img_fn for ext in [".nrrd"]
]:
img_obj = {}
img_obj["img"] = img_fn
img_obj["out"] = os.path.normpath("/".join([args.out]))
img_fn_array.append(img_obj)
for img_obj in img_fn_array:
image = img_obj["img"]
out = img_obj["out"]
print("Reading:", image)
surf = vtk.vtkNrrdReader()
surf.SetFileName(image)
surf.Update()
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInputConnection(surf.GetOutputPort())
dmc.GenerateValues(100, 1, 100)
# LAPLACIAN smooth
SmoothPolyDataFilter = vtk.vtkSmoothPolyDataFilter()
SmoothPolyDataFilter.SetInputConnection(dmc.GetOutputPort())
SmoothPolyDataFilter.SetNumberOfIterations(10)
SmoothPolyDataFilter.SetFeatureAngle(120.0)
SmoothPolyDataFilter.SetRelaxationFactor(0.6)
SmoothPolyDataFilter.Update()
# SINC smooth
# smoother = vtk.vtkWindowedSincPolyDataFilter()
# smoother.SetInputConnection(dmc.GetOutputPort())
# smoother.SetNumberOfIterations(30)
# smoother.BoundarySmoothingOff()
# smoother.FeatureEdgeSmoothingOff()
# smoother.SetFeatureAngle(120.0)
# smoother.SetPassBand(0.001)
# smoother.NonManifoldSmoothingOn()
# smoother.NormalizeCoordinatesOn()
# smoother.Update()
outputFilename = out + "/" + os.path.splitext(
os.path.basename(image))[0] + ".vtk"
Write(SmoothPolyDataFilter.GetOutput(), outputFilename)
def rendering(
dataPath,
dualSurface):
import SimpleITK as sitk
#
# writing_path='data.nii'
# reader = itk.ImageFileReader.New(FileName=dataPath)
# reader.SetFileName(dataPath)
# reader.Update()
# image_input=reader.GetOutput()
#
# # imagee_out=sitk.GetImageFromArray(imagee)
#
# writer =itk.ImageFileWriter.New()
# writer.SetFileName(writing_path)
# writer.SetInput(image_input)
# writer.Update()
img=sitk.ReadImage(dataPath)
img.SetSpacing([0.18,0.18,0.18])
sitk.WriteImage(img,dataPath)
# Read the data
if dataPath.endswith('.nii'):
reader = vtk.vtkNIFTIImageReader()
# reader.SetSpacing(1,1,1)
reader.SetFileName(dataPath)
reader.Update()
elif dataPath.endswith('.nhdr') or dataPath.endswith('.nrrd'):
reader = vtk.vtkNrrdReader()
reader.SetFileName(dataPath)
# reader.SetSpacing(0.18,0.18,0.18)
reader.Update()
else:
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(dataPath)
reader.Update()
# Smooth the image
filteredImage = gaussianFilter(reader)
# Surface rendering
if dualSurface:
dualSurfaceRendering(filteredImage)
import vtk.test.Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
'''
Prevent .pyc files from being created.
Stops the vtk source being polluted
by .pyc files.
'''
sys.dont_write_bytecode = True
# Disable object factory override for vtkNrrdReader
vtk.vtkObjectFactory.SetAllEnableFlags(False, "vtkNrrdReader",
"vtkPNrrdReader")
dataRoot = vtkGetDataRoot()
reader = vtk.vtkNrrdReader()
if len(sys.argv) > 1:
fileName = sys.argv[1]
else:
fileName = "/Users/pieper/data/multivolume/Cardiac-resampled-cropped/00rc.nrrd"
reader.SetFileName(fileName)
reader.Update()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
range = reader.GetOutput().GetScalarRange()
# Prepare 1D Transfer Functions
ctf = vtk.vtkColorTransferFunction()
def initialize(self):
global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor
# Bring used components
self.registerVtkWebProtocol(protocols.vtkWebMouseHandler())
self.registerVtkWebProtocol(protocols.vtkWebViewPort())
self.registerVtkWebProtocol(
protocols.vtkWebPublishImageDelivery(decode=False))
self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery())
# Update authentication key to use
self.updateSecret(_WebCone.authKey)
# tell the C++ web app to use no encoding.
# ParaViewWebPublishImageDelivery must be set to decode=False to match.
self.getApplication().SetImageEncoding(0)
# Create default pipeline (Only once for all the session)
if not _WebCone.view:
# VTK specific code
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle(
).SetCurrentStyleToTrackballCamera()
# cone = vtk.vtkConeSource()
# mapper = vtk.vtkPolyDataMapper()
# actor = vtk.vtkActor()
# mapper.SetInputConnection(cone.GetOutputPort())
# actor.SetMapper(mapper)
# renderer.AddActor(actor)
# load nrrd
reader = vtk.vtkNrrdReader()
reader.SetFileName('C:\\Users\\Mat\\Desktop\\tardiva3.0.nrrd')
reader.Update()
# The volume will be displayed by ray-cast alpha compositing.
# A ray-cast mapper is needed to do the ray-casting.
# volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
volume_mapper = vtk.vtkSmartVolumeMapper()
volume_mapper.SetInputConnection(reader.GetOutputPort())
volume_mapper.SetSampleDistance(0.5)
# The color transfer function maps voxel intensities to colors.
# It is modality-specific, and often anatomy-specific as well.
# The goal is to one color for flesh (between 500 and 1000)
# and another color for bone (1150 and over).
volume_color = vtk.vtkColorTransferFunction()
volume_color.AddRGBPoint(0, 0.2, 0.2, 0.7)
volume_color.AddRGBPoint(500, 240.0 / 255.0, 184.0 / 255.0,
160.0 / 255.0)
volume_color.AddRGBPoint(1000, 240.0 / 255.0, 184.0 / 255.0,
160.0 / 255.0)
volume_color.AddRGBPoint(1150, 1.0, 1.0, 240.0 / 255.0) # Ivory
# The opacity transfer function is used to control the opacity
# of different tissue types.
volume_scalar_opacity = vtk.vtkPiecewiseFunction()
volume_scalar_opacity.AddPoint(0, 0.00)
volume_scalar_opacity.AddPoint(500, 0.15)
volume_scalar_opacity.AddPoint(1000, 0.15)
volume_scalar_opacity.AddPoint(1150, 0.85)
# The gradient opacity function is used to decrease the opacity
# in the 'flat' regions of the volume while maintaining the opacity
# at the boundaries between tissue types. The gradient is measured
# as the amount by which the intensity changes over unit distance.
# For most medical data, the unit distance is 1mm.
volume_gradient_opacity = vtk.vtkPiecewiseFunction()
volume_gradient_opacity.AddPoint(0, 0.0)
volume_gradient_opacity.AddPoint(90, 0.5)
volume_gradient_opacity.AddPoint(100, 1.0)
# The VolumeProperty attaches the color and opacity functions to the
# volume, and sets other volume properties. The interpolation should
# be set to linear to do a high-quality rendering. The ShadeOn option
# turns on directional lighting, which will usually enhance the
# appearance of the volume and make it look more '3D'. However,
# the quality of the shading depends on how accurately the gradient
# of the volume can be calculated, and for noisy data the gradient
# estimation will be very poor. The impact of the shading can be
# decreased by increasing the Ambient coefficient while decreasing
# the Diffuse and Specular coefficient. To increase the impact
# of shading, decrease the Ambient and increase the Diffuse and Specular.
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(volume_color)
volume_property.SetScalarOpacity(volume_scalar_opacity)
volume_property.SetGradientOpacity(volume_gradient_opacity)
volume_property.SetInterpolationTypeToLinear()
volume_property.ShadeOn()
volume_property.SetAmbient(0.4)
volume_property.SetDiffuse(0.6)
volume_property.SetSpecular(0.2)
# The vtkVolume is a vtkProp3D (like a vtkActor) and controls the position
# and orientation of the volume in world coordinates.
volumeActor = vtk.vtkVolume()
volumeActor.SetMapper(volume_mapper)
volumeActor.SetProperty(volume_property)
# Finally, add the volume to the renderer
renderer.AddActor(volumeActor)
##########################
# renderer.AddActor(actor)
# render
renderer.ResetCamera()
renderWindow.Render()
# VTK Web application specific
_WebCone.view = renderWindow
self.getApplication().GetObjectIdMap().SetActiveObject(
"VIEW", renderWindow)
import vtk.test.Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
'''
Prevent .pyc files from being created.
Stops the vtk source being polluted
by .pyc files.
'''
sys.dont_write_bytecode = True
# Disable object factory override for vtkNrrdReader
vtk.vtkObjectFactory.SetAllEnableFlags(False, "vtkNrrdReader", "vtkPNrrdReader")
dataRoot = vtkGetDataRoot()
reader = vtk.vtkNrrdReader()
reader.SetFileName("" + str(dataRoot) + "/Data/tooth.nhdr")
reader.Update()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationType(vtk.VTK_LINEAR_INTERPOLATION)
range = reader.GetOutput().GetScalarRange()
# Prepare 1D Transfer Functions
ctf = vtk.vtkColorTransferFunction()
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)
def rendering(dataPath, dualSurface, img1_path, img2_path, img3_path,
img4_path):
import SimpleITK as sitk
#
# writing_path='data.nii'
# reader = itk.ImageFileReader.New(FileName=dataPath)
# reader.SetFileName(dataPath)
# reader.Update()
# image_input=reader.GetOutput()
#
# # imagee_out=sitk.GetImageFromArray(imagee)
#
# writer =itk.ImageFileWriter.New()
# writer.SetFileName(writing_path)
# writer.SetInput(image_input)
# writer.Update()
img_facial = sitk.ReadImage(img1_path)
img_facial.SetSpacing(Sspacing)
img_sigmoid = sitk.ReadImage(img2_path)
img_sigmoid.SetSpacing(Sspacing)
img_tensor = sitk.ReadImage(img3_path)
img_tensor.SetSpacing(Sspacing)
img_inner = sitk.ReadImage(img4_path)
img_inner.SetSpacing(Sspacing)
segmented_path = "segmented_path.nrrd"
img_segmented = sitk.AddImageFilter()
img_1 = img_segmented.Execute(img_facial, img_sigmoid)
img_segmented2 = sitk.AddImageFilter()
img_2 = img_segmented2.Execute(img_tensor, img_inner)
img_segmented3 = sitk.AddImageFilter()
img_3 = img_segmented3.Execute(img_1, img_2)
img_3.SetOrigin([0, 0, 0])
sitk.WriteImage(img_3, segmented_path)
img = sitk.ReadImage(dataPath)
img.SetSpacing(Sspacing)
img.SetOrigin([0, 0, 0])
sitk.WriteImage(img, dataPath)
# Read the data
if dataPath.endswith('.nii'):
reader = vtk.vtkNIFTIImageReader()
# reader.SetSpacing(1,1,1)
reader.SetFileName(dataPath)
reader.Update()
elif dataPath.endswith('.nhdr') or dataPath.endswith('.nrrd'):
reader = vtk.vtkNrrdReader()
reader.SetFileName(dataPath)
# reader.SetSpacing(0.18,0.18,0.18)
reader.Update()
else:
reader = vtk.vtkDICOMImageReader()
reader.SetDirectoryName(dataPath)
reader.Update()
if segmented_path.endswith('.nii'):
reader2 = vtk.vtkNIFTIImageReader()
# reader.SetSpacing(1,1,1)
reader2.SetFileName(segmented_path)
reader2.Update()
elif segmented_path.endswith('.nhdr') or dataPath.endswith('.nrrd'):
reader2 = vtk.vtkNrrdReader()
reader2.SetFileName(segmented_path)
# reader.SetSpacing(0.18,0.18,0.18)
reader2.Update()
else:
reader2 = vtk.vtkDICOMImageReader()
reader2.SetDirectoryName(segmented_path)
reader2.Update()
stl1 = "part1.stl"
stl2 = "part2.stl"
# Smooth the image
filteredImage = gaussianFilter(reader)
# Surface rendering
if dualSurface:
dualSurfaceRendering(filteredImage, stl1)
# Smooth the image
filteredImage2 = gaussianFilter(reader2)
# Surface rendering
if dualSurface:
dualSurfaceRendering(filteredImage2, stl2)
def __init__(self, parent = None):
self.reader = vtk.vtkNrrdReader()
self.dataExtent = []
self.dataDimensions = []
self.dataRange = ()
# initialize GUI
QtWidgets.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)]
[self.viewerXY2, self.viewerYZ2, self.viewerXZ2] = [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)
self.colorTable = vtk.vtkLookupTable()
self.colorTable.SetNumberOfColors(1)
self.colorTable.SetTableValue(0, 0, 1, 0, 1)
self.colorTable.Build()
self.colorMap = vtk.vtkImageMapToColors()
# 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()
# 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.vtkFixedPointVolumeRayCastMapper()
#self.volumeMapper.SetBlendModeToComposite()
#self.volumeMapper.SetVolumeRayCastFunction(self.rayCastFunction)
self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
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)
width_bar = self.ui.WindowWidthSlider
center_bar = self.ui.WindowCenterSlider
width_bar.valueChanged.connect(self.changeValue)
center_bar.valueChanged.connect(self.changeValue)
def process(in_file, out_dir, width, height, angle_step, preset):
# Importing vtk package can be quite slow, only do it if CLI validation passes
from vtk import (vtkMetaImageReader, vtkGPUVolumeRayCastMapper,
vtkColorTransferFunction, vtkPiecewiseFunction,
vtkNrrdReader, vtkVolumeProperty, vtkVolume,
vtkRenderWindow, vtkRenderer, vtkCamera,
vtkXMLImageDataReader, vtkDICOMImageReader,
VTK_LINEAR_INTERPOLATION)
from vtk.web.dataset_builder import ImageDataSetBuilder
phi_vals, theta_vals = get_angle_samples(angle_step)
if os.path.isdir(in_file):
# If it's a directory, assume it's DICOM
reader = vtkDICOMImageReader()
else:
ext = os.path.splitext(in_file)[1].lower()
if ext == '.mha':
reader = vtkMetaImageReader()
elif ext == '.nrrd':
reader = vtkNrrdReader()
elif ext == '.vti':
reader = vtkXMLImageDataReader()
elif ext == '.tre':
# TODO refactor this to reduce duplication of visualization code
return process_tre(in_file, out_dir, phi_vals, theta_vals, width,
height)
else:
raise Exception('Unknown file type, cannot read: ' + in_file)
reader.SetFileName(in_file)
reader.Update()
field_range = reader.GetOutput().GetPointData().GetScalars().GetRange()
mapper = vtkGPUVolumeRayCastMapper()
mapper.SetInputConnection(reader.GetOutputPort())
color_function = vtkColorTransferFunction()
scalar_opacity = vtkPiecewiseFunction()
volume_property = vtkVolumeProperty()
if preset is None or preset == 'default': # some sensible naive default
color_function.AddRGBPoint(field_range[0], 0., 0., 0.)
color_function.AddRGBPoint(field_range[1], 1., 1., 1.)
scalar_opacity.AddPoint(field_range[0], 0.)
scalar_opacity.AddPoint(field_range[1], 1.)
elif preset in MEDICAL_XFER_PRESETS:
setup_vr(color_function, scalar_opacity, volume_property,
MEDICAL_XFER_PRESETS[preset])
else:
raise Exception('Unknown transfer function preset: %s' % preset)
volume_property.SetInterpolationType(VTK_LINEAR_INTERPOLATION)
volume_property.SetColor(color_function)
volume_property.SetScalarOpacity(scalar_opacity)
volume = vtkVolume()
volume.SetMapper(mapper)
volume.SetProperty(volume_property)
window = vtkRenderWindow()
window.SetSize(width, height)
renderer = vtkRenderer()
window.AddRenderer(renderer)
renderer.AddVolume(volume)
camera = vtkCamera()
renderer.SetActiveCamera(camera)
renderer.ResetCamera()
window.Render()
idb = ImageDataSetBuilder(out_dir, 'image/jpg', {
'type': 'spherical',
'phi': phi_vals,
'theta': theta_vals
})
idb.start(window, renderer)
idb.writeImages()
idb.stop()
def view_3d(filename):
# Create the renderer, the render window, and the interactor. The renderer
# draws into the render window, the interactor enables mouse- and
# keyboard-based interaction with the scene.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The following reader is used to read a Nrrd file
v16 = vtk.vtkNrrdReader()
v16.SetFileName(filename)
v16.Update()
# The volume will be displayed by ray-cast alpha compositing.
# A ray-cast mapper is needed to do the ray-casting, and a
# compositing function is needed to do the compositing along the ray.
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(v16.GetOutputPort())
volumeMapper.SetBlendModeToComposite()
# The color transfer function maps voxel intensities to colors.
# It is modality-specific, and often anatomy-specific as well.
# The goal is to one color for flesh (between 300 and 1000)
# and another color for bone (1150 and over).
volumeColor = vtk.vtkColorTransferFunction()
volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0)
volumeColor.AddRGBPoint(300, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(1000, 1.0, 0.5, 0.3)
volumeColor.AddRGBPoint(1150, 1.0, 1.0, 0.9)
# The opacity transfer function is used to control the opacity
# of different tissue types.
volumeScalarOpacity = vtk.vtkPiecewiseFunction()
volumeScalarOpacity.AddPoint(0, 0.00)
volumeScalarOpacity.AddPoint(300, 0.15)
volumeScalarOpacity.AddPoint(1000, 0.15)
volumeScalarOpacity.AddPoint(1150, 0.85)
# The gradient opacity function is used to decrease the opacity
# in the "flat" regions of the volume while maintaining the opacity
# at the boundaries between tissue types. The gradient is measured
# as the amount by which the intensity changes over unit distance.
# For most medical data, the unit distance is 1mm.
volumeGradientOpacity = vtk.vtkPiecewiseFunction()
volumeGradientOpacity.AddPoint(0, 0.0)
volumeGradientOpacity.AddPoint(90, 0.5)
volumeGradientOpacity.AddPoint(100, 1.0)
# The VolumeProperty attaches the color and opacity functions to the
# volume, and sets other volume properties. The interpolation should
# be set to linear to do a high-quality rendering. The ShadeOn option
# turns on directional lighting, which will usually enhance the
# appearance of the volume and make it look more "3D". However,
# the quality of the shading depends on how accurately the gradient
# of the volume can be calculated, and for noisy data the gradient
# estimation will be very poor. The impact of the shading can be
# decreased by increasing the Ambient coefficient while decreasing
# the Diffuse and Specular coefficient. To increase the impact
# of shading, decrease the Ambient and increase the Diffuse and Specular.
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)
# The vtkVolume is a vtkProp3D (like a vtkActor) and controls the position
# and orientation of the volume in world coordinates.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# Finally, add the volume to the renderer
ren.AddViewProp(volume)
# Set up an initial view of the volume. The focal point will be the
# center of the volume, and the camera position will be 400mm to the
# patient's left (which is our right).
camera = ren.GetActiveCamera()
c = volume.GetCenter()
camera.SetFocalPoint(c[0], c[1], c[2])
camera.SetPosition(c[0] + 400, c[1], c[2])
camera.SetViewUp(0, 0, -1)
# Increase the size of the render window
renWin.SetSize(1000, 800)
# Interact with the data.
iren.Initialize()
renWin.Render()
iren.Start()
