def __init__(self):
# Objects for volume rendering
self.volume = vtk.vtkVolume()
self.volumeMapper = vtk.vtkSmartVolumeMapper()
self.volumeProperty = vtk.vtkVolumeProperty()
# Objects for slice rendering
self.sliceActor = vtk.vtkImageActor()
self.sliceMapper = vtk.vtkImageResliceMapper()
self.sliceProperty = vtk.vtkImageProperty()
# Objects for importing and reslicing the data
self.importer = [vtk.vtkImageImport()]
self.slice = [vtk.vtkImageResliceToColors()]
# Objects that point to the output algorithms
# These must be specified at run time by the implementing class
self.output = None
self.sliceOutput = None
# Some properties of the data
self.numberOfDataSets = 0
self.numberOfTimeFrames = 0
self.currentTimeFrame = 0
self.dimensions = [0, 0, 0]
def extract_slice_gut(self, origin, tangent, normal, binormal):
'''
This works but can't clip slice.
'''
print(" ")
print("---------- Image Extract Slice ----------")
print("origin: " + str(origin))
print("tangent: " + str(tangent))
print("normal: " + str(normal))
print("binormal: " + str(binormal))
# Define the slice plane.
slice_plane = vtk.vtkPlane()
slice_plane.SetOrigin(origin[0], origin[1], origin[2])
slice_plane.SetNormal(tangent[0], tangent[1], tangent[2])
## Create a mapper that slice a 3D image with an abitrary slice plane
# and draw the results on the screen.
#
reslice_mapper = vtk.vtkImageResliceMapper()
reslice_mapper.SetInputData(self.volume)
reslice_mapper.SliceFacesCameraOff()
reslice_mapper.SliceAtFocalPointOff()
reslice_mapper.SetSlicePlane(slice_plane)
reslice_mapper.Update()
## vtkImageSlice is used to represent an image in a 3D scene.
#
image_slice = vtk.vtkImageSlice()
image_slice.SetMapper(reslice_mapper)
image_slice.Update()
self.graphics.add_actor(image_slice)
print("Image slice: ")
bounds = 6 * [0]
image_slice.GetBounds(bounds)
print(" Bounds: " + str(bounds))
#print(str(image_slice))
## Show slice bounds.
#
imageBoundsCube = vtk.vtkCubeSource()
imageBoundsCube.SetBounds(self.bounds)
imageBoundsCube.Update()
#
cutter = vtk.vtkCutter()
cutter.SetCutFunction(slice_plane)
cutter.SetInputData(imageBoundsCube.GetOutput())
cutter.Update()
cutterMapper = vtk.vtkPolyDataMapper()
cutterMapper.SetInputData(cutter.GetOutput())
#
planeBorder = vtk.vtkActor()
planeBorder.GetProperty().SetColor(1.0, 1.0, 0)
planeBorder.GetProperty().SetOpacity(1.0)
planeBorder.GetProperty().SetLighting(0)
planeBorder.GetProperty().SetLineWidth(4)
planeBorder.SetMapper(cutterMapper)
self.graphics.add_actor(planeBorder)
def Slicer2d(volume, size=(900, 900), bg=(0.6, 0.6, 0.7), zoom=1.3):
"""Create a 2D window with a single balck a nd white
slice of a Volume, wich can be oriented arbitrarily in space.
"""
img = volume.imagedata()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
im = vtk.vtkImageResliceMapper()
im.SetInputData(img)
im.SliceFacesCameraOn()
im.SliceAtFocalPointOn()
im.BorderOn()
ip = vtk.vtkImageProperty()
ip.SetInterpolationTypeToLinear()
ia = vtk.vtkImageSlice()
ia.SetMapper(im)
ia.SetProperty(ip)
ren1.AddViewProp(ia)
ren1.SetBackground(bg)
renWin.SetSize(size)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImage3D()
iren.SetInteractorStyle(style)
renWin.SetInteractor(iren)
renWin.Render()
cam1 = ren1.GetActiveCamera()
cam1.ParallelProjectionOn()
ren1.ResetCameraClippingRange()
cam1.Zoom(zoom)
renWin.Render()
printc("Slicer2D tool", invert=1, c="m")
printc(
"""Press SHIFT+Left mouse to rotate the camera for oblique slicing
SHIFT+Middle mouse to slice perpendicularly through the image
Left mouse and Drag to modify luminosity and contrast
X to Reset to sagittal view
Y to Reset to coronal view
Z to Reset to axial view
R to Reset the Window/Levels
Q to Quit.""",
c="m",
)
iren.Start()
return iren
def setWidgetView(self, widget):
self.initView(self.parent.getData('fix'), widget)
data = self.parent.getData()
image_type = data.getITKImageType()
self.image2 = data.getITKImage()
self.space2 = data.getResolution().tolist()
if len(self.space2) == 3:
self.space2 = [float(x) / self.space2[-1] for x in self.space2]
self.image2.SetSpacing(self.space2)
shapeList = data.getData().shape
y, x = shapeList[-2], shapeList[-1]
itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New()
itk_vtk_converter.SetInput(self.image2)
image_resample = vtk.vtkImageResample()
image_resample.SetInput(itk_vtk_converter.GetOutput())
self.renderer2 = vtk.vtkRenderer()
self.render_window.AddRenderer(self.renderer2)
self.reslice_mapper2 = vtk.vtkImageResliceMapper()
self.reslice_mapper2.SetInput(image_resample.GetOutput())
self.reslice_mapper2.SliceFacesCameraOn()
self.reslice_mapper2.SliceAtFocalPointOn()
self.reslice_mapper2.JumpToNearestSliceOn()
self.reslice_mapper2.BorderOff()
self.reslice_mapper2.BackgroundOn()
array = data.getData()
self.minI2 = array.min()
self.maxI2 = array.max()
self.image_slice2 = vtk.vtkImageSlice()
self.image_slice2.SetMapper(self.reslice_mapper2)
image_property2 = vtk.vtkImageProperty()
image_property2.SetColorWindow(self.maxI2 - self.minI2)
image_property2.SetColorLevel((self.maxI2 + self.minI2) / 2.0)
image_property2.SetAmbient(0.0)
image_property2.SetDiffuse(1.0)
image_property2.SetOpacity(1.0)
image_property2.SetInterpolationTypeToLinear()
self.image_slice2.SetProperty(image_property2)
self.renderer2.AddViewProp(self.image_slice2)
self.renderer.SetViewport(0, 0, 0.5, 1)
self.renderer2.SetViewport(0.5, 0, 1, 1)
self.renderer2.SetActiveCamera(self.camera)
self.render_window.Render()
def setup_projection(brain, renderer):
slice_mapper = vtk.vtkImageResliceMapper()
slice_mapper.SetInputConnection(brain.reader.GetOutputPort())
slice_mapper.SliceFacesCameraOn()
slice_mapper.SliceAtFocalPointOn()
slice_mapper.BorderOff()
brain_image_prop = vtk.vtkImageProperty()
brain_image_prop.SetOpacity(0.0)
brain_image_prop.SetInterpolationTypeToLinear()
image_slice = vtk.vtkImageSlice()
image_slice.SetMapper(slice_mapper)
image_slice.SetProperty(brain_image_prop)
image_slice.GetMapper().SetInputConnection(
brain.image_mapper.GetOutputPort())
renderer.AddViewProp(image_slice)
return brain_image_prop
def update_mapper(self):
mapper = vtk.vtkImageResliceMapper()
mapper.SetInputData(self._volume)
mapper.SliceFacesCameraOff()
mapper.SliceAtFocalPointOff()
mapper.JumpToNearestSliceOn()
mapper.SetImageSampleFactor(2)
mapper.BorderOn()
mapper.BackgroundOff()
mapper.UpdateInformation()
mapper.GetSlicePlane().SetOrigin(*self._origin)
mapper.GetSlicePlane().SetNormal(*self._normal)
mapper.GetSlicePlane().Modified()
mapper.Modified()
mapper.Update()
self._mapper = mapper
def load_slice(image):
im = vtk.vtkImageResliceMapper()
im.SetInputConnection(image)
im.BorderOff()
plane = im.GetSlicePlane()
plane.SetNormal(1.0, 0.0, 0.0)
plane.SetOrigin(114, 114, 50)
ip = vtk.vtkImageProperty()
ip.SetColorWindow(2000)
ip.SetColorLevel(500)
ip.SetAmbient(0.0)
ip.SetDiffuse(1.0)
ip.SetOpacity(1.0)
ip.SetInterpolationTypeToLinear()
ia = vtk.vtkImageSlice()
ia.SetMapper(im)
ia.SetProperty(ip)
return im, ia
def VisualizeSegmentation(input_filename, segmentation_filename, window, level,
nThreads, opacity):
# Python 2/3 compatible input
from six.moves import input
# Read input
for filename in [input_filename, segmentation_filename]:
if not os.path.isfile(filename):
os.sys.exit('[ERROR] Cannot find file \"{}\"'.format(filename))
# Set a minimum thread count
nThreads = max(1, nThreads)
# Max/min opacity
opacity = max(0, opacity)
opacity = min(1, opacity)
# Read the input
image_reader = get_vtk_reader(input_filename)
if image_reader is None:
os.sys.exit('[ERROR] Cannot find reader for file \"{}\"'.format(
input_filename))
print('Reading input image ' + input_filename)
image_reader.SetFileName(input_filename)
image_reader.Update()
# Read the segmentation
seg_reader = get_vtk_reader(segmentation_filename)
if seg_reader is None:
os.sys.exit('[ERROR] Cannot find reader for file \"{}\"'.format(
segmentation_filename))
print('Reading input image ' + segmentation_filename)
seg_reader.SetFileName(segmentation_filename)
seg_reader.Update()
# Get scalar range for W/L and padding
image_scalar_range = image_reader.GetOutput().GetScalarRange()
# Determine if we need to autocompute the window/level
if window <= 0:
window = image_scalar_range[1] - image_scalar_range[0]
level = (image_scalar_range[1] + image_scalar_range[0]) / 2
# Get data range
seg_scalar_range = [
int(x) for x in seg_reader.GetOutput().GetScalarRange()
]
if seg_scalar_range[0] < 0:
os.sys.exit(
"Segmentation image \"{}\" has values less than zero which cannot currently be handled. Exiting..."
.format(segmentation_filename))
nLabels = seg_scalar_range[1]
print("Segmented image has {} labels".format(nLabels))
# Setup LUT
segLUT = vtk.vtkLookupTable()
segLUT.SetRange(0, nLabels)
segLUT.SetRampToLinear()
segLUT.SetAlphaRange(1, 1) # Make it slightly transparent
segLUT.Build()
segLUT.SetTableValue(0, 0.0, 0.0, 0.0,
0.0) # Set zero to black, transparent
# Setup input Mapper + Property -> Slice
inputMapper = vtk.vtkImageResliceMapper()
inputMapper.SetInputConnection(image_reader.GetOutputPort())
inputMapper.SliceAtFocalPointOn()
inputMapper.SliceFacesCameraOn()
inputMapper.BorderOn()
inputMapper.SetNumberOfThreads(nThreads)
inputMapper.ResampleToScreenPixelsOn()
inputMapper.StreamingOn()
imageProperty = vtk.vtkImageProperty()
imageProperty.SetColorLevel(level)
imageProperty.SetColorWindow(window)
imageProperty.SetLayerNumber(1)
imageProperty.SetInterpolationTypeToNearest()
inputSlice = vtk.vtkImageSlice()
inputSlice.SetMapper(inputMapper)
inputSlice.SetProperty(imageProperty)
# Setup seg Mapper + Property -> Slice
segImageProperty = vtk.vtkImageProperty()
segImageProperty.SetLookupTable(segLUT)
segImageProperty.UseLookupTableScalarRangeOn()
segImageProperty.SetInterpolationTypeToLinear()
segImageProperty.SetOpacity(opacity)
segImageProperty.SetLayerNumber(2)
segImageProperty.SetInterpolationTypeToNearest()
segMapper = vtk.vtkImageResliceMapper()
segMapper.SetInputConnection(seg_reader.GetOutputPort())
segMapper.SliceAtFocalPointOn()
segMapper.SliceFacesCameraOn()
segMapper.BorderOn()
segMapper.SetNumberOfThreads(nThreads)
segMapper.ResampleToScreenPixelsOn()
segMapper.StreamingOn()
segSlice = vtk.vtkImageSlice()
segSlice.SetProperty(segImageProperty)
segSlice.SetMapper(segMapper)
# Add everything to a vtkImageStack
imageStack = vtk.vtkImageStack()
imageStack.AddImage(inputSlice)
imageStack.AddImage(segSlice)
imageStack.SetActiveLayer(1)
# Create Renderer -> RenderWindow -> RenderWindowInteractor -> InteractorStyle
renderer = vtk.vtkRenderer()
renderer.AddViewProp(imageStack)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactorStyle = vtk.vtkInteractorStyleImage()
interactorStyle.SetInteractionModeToImageSlicing()
interactorStyle.KeyPressActivationOn()
interactor.SetInteractorStyle(interactorStyle)
interactor.SetRenderWindow(renderWindow)
# Add some functionality to switch layers for window/level
def layerSwitcher(obj, event):
if str(interactor.GetKeyCode()) == 'w':
# Print the w/l for the image
print("Image W/L: {w}/{l}".format(w=imageProperty.GetColorWindow(),
l=imageProperty.GetColorLevel()))
elif str(interactor.GetKeyCode()) == 'n':
# Set interpolation to nearest neighbour (good for voxel visualization)
imageProperty.SetInterpolationTypeToNearest()
interactor.Render()
elif str(interactor.GetKeyCode()) == 'c':
# Set interpolation to cubic (makes a better visualization)
imageProperty.SetInterpolationTypeToCubic()
interactor.Render()
elif str(interactor.GetKeyCode()) == 'r':
window = image_scalar_range[1] - image_scalar_range[0]
level = (image_scalar_range[1] + image_scalar_range[0]) / 2
imageProperty.SetColorLevel(level)
imageProperty.SetColorWindow(window)
interactor.Render()
# Add ability to switch between active layers
interactor.AddObserver('KeyPressEvent', layerSwitcher,
-1.0) # Call layerSwitcher as last observer
# Initialize and go
interactor.Initialize()
interactor.Start()
iren.SetRenderWindow(renWin)
for i in range(0, 3):
print i
# Create the RenderWindow, Renderer
ren1 = vtk.vtkRenderer()
ren1.SetBackground(0.1, 0.2, 0.4)
if i == 0:
ren1.SetViewport(0.0, 0.0, 0.333, 1)
elif i == 1:
ren1.SetViewport(0.333, 0.0, 0.667, 1)
elif i == 2:
ren1.SetViewport(0.667, 0.0, 1.0, 1.0)
renWin.AddRenderer(ren1)
im = vtk.vtkImageResliceMapper()
im.SetInputConnection(reader.GetOutputPort())
im.SliceFacesCameraOn()
im.SliceAtFocalPointOn()
im.BorderOff()
ip = vtk.vtkImageProperty()
ip.SetColorWindow(2000)
ip.SetColorLevel(1000)
ip.SetAmbient(0.0)
ip.SetDiffuse(1.0)
ip.SetOpacity(1.0)
ip.SetInterpolationTypeToLinear()
bounds = im.GetBounds()
print bounds
# Determine window/level if needed
print("Window/Level:")
window = args.window
level = args.level
for i in range(len(args.window)):
# Check if we should calculate (cannot have window less than or equal to zero)
if args.window[i] <= 0:
window[i] = scalarRanges[i][1] - scalarRanges[i][0]
level[i] = (scalarRanges[i][1] + scalarRanges[i][0]) / 2
# Print resulting window/level
print("\tImage {i}: {w}/{l}".format(i=i + 1, w=window[i], l=level[i]))
# Setup input1 Mapper + Property -> Slice
input1Mapper = vtk.vtkImageResliceMapper()
input1Mapper.SetInputConnection(reader1.GetOutputPort())
input1Mapper.SliceAtFocalPointOn()
input1Mapper.SliceFacesCameraOn()
input1Mapper.BorderOff()
input1Mapper.SetNumberOfThreads(args.nThreads)
input1Mapper.ResampleToScreenPixelsOn()
input1Mapper.StreamingOn()
image1Property = vtk.vtkImageProperty()
image1Property.SetColorLevel(level[0])
image1Property.SetColorWindow(window[0])
image1Property.SetInterpolationTypeToCubic()
image1Property.CheckerboardOn()
image1Property.SetCheckerboardSpacing(args.divisions)
image1Property.SetLayerNumber(1)
scalarRange = [int(x) for x in segReader.GetOutput().GetScalarRange()]
if scalarRange[0] < 0:
os.sys.exit("Segmentation image \"{}\" has values less than zero which cannot currently be handled. Exiting...".format(args.inputSegmentation))
nLabels = scalarRange[1]
print("Segmented image has {} labels".format(nLabels))
# Setup LUT
segLUT = vtk.vtkLookupTable()
segLUT.SetRange(0,nLabels)
segLUT.SetRampToLinear()
segLUT.SetAlphaRange(1,1) # Make it slightly transparent
segLUT.Build()
segLUT.SetTableValue(0, 0.0, 0.0, 0.0, 0.0 ) # Set zero to black, transparent
# Setup input Mapper + Property -> Slice
inputMapper = vtk.vtkImageResliceMapper()
inputMapper.SetInputConnection(inputReader.GetOutputPort())
inputMapper.SliceAtFocalPointOn()
inputMapper.SliceFacesCameraOn()
inputMapper.BorderOn()
inputMapper.SetNumberOfThreads(args.nThreads)
inputMapper.ResampleToScreenPixelsOn()
inputMapper.StreamingOn()
imageProperty = vtk.vtkImageProperty()
imageProperty.SetColorLevel(args.level)
imageProperty.SetColorWindow(args.window)
imageProperty.SetLayerNumber(1)
imageProperty.SetInterpolationTypeToNearest()
inputSlice = vtk.vtkImageSlice()
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
else:
fileName = 'c:/github/fis/data/Abdomen/CT-Abdomen.mhd'
reader = vtk.vtkMetaImageReader()
reader.SetFileName(fileName)
reader.Update()
# You can call SetSlicePlane on the the mapper
# Create the RenderWindow, Renderer
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
im = vtk.vtkImageResliceMapper()
im.SetInputConnection(reader.GetOutputPort())
im.SliceFacesCameraOn()
im.SliceAtFocalPointOn()
im.BorderOff()
ip = vtk.vtkImageProperty()
ip.SetColorWindow(2000)
ip.SetColorLevel(1000)
ip.SetAmbient(0.0)
ip.SetDiffuse(1.0)
ip.SetOpacity(1.0)
ip.SetInterpolationTypeToLinear()
ia = vtk.vtkImageSlice()
ia.SetMapper(im)
def render(input_file, output_file, histogram_bin_count):
path, output_name = split(output_file)
output_root, ext = splitext(output_name)
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(input_file)
reader.Update()
output = reader.GetOutput()
size = output.GetDimensions()
center = output.GetCenter()
spacing = output.GetSpacing()
center1 = (center[0], center[1], center[2])
center2 = (center[0], center[1], center[2])
if size[2] % 2 == 1:
center1 = (center[0], center[1], center[2] + 0.5*spacing[2])
if size[0] % 2 == 1:
center2 = (center[0] + 0.5*spacing[0], center[1], center[2])
vrange = output.GetScalarRange()
avg_scale = 0.25 * (vrange[1]-vrange[0])
avg_map_top = vtk.vtkImageResliceMapper()
avg_map_top.BorderOn()
avg_map_top.SliceAtFocalPointOn()
avg_map_top.SliceFacesCameraOn()
avg_map_top.SetSlabThickness(max(size))
avg_map_top.SetInputConnection(reader.GetOutputPort())
avg_map_side = vtk.vtkImageResliceMapper()
avg_map_side.BorderOn()
avg_map_side.SliceAtFocalPointOn()
avg_map_side.SliceFacesCameraOn()
avg_map_side.SetSlabThickness(max(size))
avg_map_side.SetInputConnection(reader.GetOutputPort())
avg_top = vtk.vtkImageSlice()
avg_top.SetMapper(avg_map_top)
avg_top.GetProperty().SetColorWindow(avg_scale)
avg_top.GetProperty().SetColorLevel(0.5*avg_scale)
avg_side = vtk.vtkImageSlice()
avg_side.SetMapper(avg_map_side)
avg_side.GetProperty().SetColorWindow(avg_scale)
avg_side.GetProperty().SetColorLevel(0.5*avg_scale)
slice_scale = vrange[1]-vrange[0]
slice_map_top = vtk.vtkImageSliceMapper()
slice_map_top.BorderOn()
slice_map_top.SliceAtFocalPointOn()
slice_map_top.SliceFacesCameraOn()
slice_map_top.SetInputConnection(reader.GetOutputPort())
slice_map_side = vtk.vtkImageSliceMapper()
slice_map_side.BorderOn()
slice_map_side.SliceAtFocalPointOn()
slice_map_side.SliceFacesCameraOn()
slice_map_side.SetInputConnection(reader.GetOutputPort())
slice_top = vtk.vtkImageSlice()
slice_top.SetMapper(slice_map_top)
slice_top.GetProperty().SetColorWindow(slice_scale)
slice_top.GetProperty().SetColorLevel(0.5*slice_scale)
slice_side = vtk.vtkImageSlice()
slice_side.SetMapper(slice_map_side)
slice_side.GetProperty().SetColorWindow(slice_scale)
slice_side.GetProperty().SetColorLevel(0.5*slice_scale)
text1_actor = vtk.vtkTextActor()
text1_actor.SetInput("min {:.5g}, max {:.5g}".format(vrange[0], vrange[1]))
text1_actor.SetPosition(0.1 * center1[0], 0.1 * center1[1])
text1_actor.GetTextProperty().SetFontSize(18)
text1_actor.GetTextProperty().SetColor(1,1,1)
text2_actor = vtk.vtkTextActor()
text2_actor.SetInput("Scaled Average")
text2_actor.SetPosition(0.1 * center1[0], 1.8 * size[1])
text2_actor.GetTextProperty().SetFontSize(24)
text2_actor.GetTextProperty().SetColor(1,1,1)
text3_actor = vtk.vtkTextActor()
text3_actor.SetInput("Slice")
text3_actor.SetPosition(0.1 * center1[0], 1.8 * size[1])
text3_actor.GetTextProperty().SetFontSize(24)
text3_actor.GetTextProperty().SetColor(1,1,1)
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
ren3 = vtk.vtkRenderer()
ren4 = vtk.vtkRenderer()
ren1.SetViewport(0, 0, 0.5,0.5)
ren2.SetViewport(0.5,0, 1.0,0.5)
ren3.SetViewport(0, 0.5,0.5,1.0)
ren4.SetViewport(0.5,0.5,1.0,1.0)
ren1.AddViewProp(slice_top)
ren2.AddViewProp(slice_side)
ren3.AddViewProp(avg_top)
ren4.AddViewProp(avg_side)
ren1.AddActor(text1_actor)
ren3.AddActor(text2_actor)
ren1.AddActor(text3_actor)
cam1 = ren1.GetActiveCamera()
cam1.ParallelProjectionOn()
cam1.SetParallelScale(0.5*spacing[1]*size[1])
cam1.SetFocalPoint(center1[0], center1[1], center1[2])
cam1.SetPosition(center1[0], center1[1], center1[2] - 100.0)
cam2 = ren2.GetActiveCamera()
cam2.ParallelProjectionOn()
cam2.SetParallelScale(0.5*spacing[1]*size[1])
cam2.SetFocalPoint(center2[0], center2[1], center2[2])
cam2.SetPosition(center2[0] + 100.0, center2[1], center2[2])
cam3 = ren3.GetActiveCamera()
cam3.ParallelProjectionOn()
cam3.SetParallelScale(0.5*spacing[1]*size[1])
cam3.SetFocalPoint(center1[0], center1[1], center1[2])
cam3.SetPosition(center1[0], center1[1], center1[2] - 100.0)
cam4 = ren4.GetActiveCamera()
cam4.ParallelProjectionOn()
cam4.SetParallelScale(0.5*spacing[1]*size[1])
cam4.SetFocalPoint(center2[0], center2[1], center2[2])
cam4.SetPosition(center2[0] + 100.0, center2[1], center2[2])
ren_win = vtk.vtkRenderWindow()
ren_win.SetSize(2 * (size[0] + size[2]) // 2 * 2, 4 * size[1] // 2 * 2) # keep size even
ren_win.AddRenderer(ren1)
ren_win.AddRenderer(ren2)
ren_win.AddRenderer(ren3)
ren_win.AddRenderer(ren4)
ren_win.Render()
# screenshot code:
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(ren_win)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName(output_file)
writer.SetInputConnection(w2if.GetOutputPort())
writer.Write()
marching_cubes = vtk.vtkMarchingCubes()
marching_cubes.SetInputConnection(reader.GetOutputPort())
marching_cubes.ComputeNormalsOn()
marching_cubes.ComputeGradientsOn()
marching_cubes.SetValue(0, 0.1 * vrange[1])
stl_output = join(path, output_root + '_isosurface.stl')
stl_writer = vtk.vtkSTLWriter()
stl_writer.SetFileName(stl_output)
stl_writer.SetInputConnection(marching_cubes.GetOutputPort())
stl_writer.Write()
# histogram code:
num_bins = int(histogram_bin_count)
histogram = vtk.vtkImageHistogram()
histogram.SetInputConnection(reader.GetOutputPort())
histogram.AutomaticBinningOn()
histogram.SetMaximumNumberOfBins(num_bins)
histogram.Update()
origin = histogram.GetBinOrigin()
spacing = histogram.GetBinSpacing()
bin_values = np.linspace(0, num_bins * spacing, num=num_bins, endpoint=False)
hist_output = join(path, output_root + '_hist.txt')
hist_values = numpy_support.vtk_to_numpy(histogram.GetHistogram())
if len(hist_values) != len(bin_values):
raise Exception('Histogram values and bins do not match')
hist_mat = np.column_stack((bin_values, hist_values))
np.savetxt(hist_output, hist_mat, fmt='%.9g')
def __init__(self, inputobj=None):
vtk.vtkImageSlice.__init__(self)
Base3DProp.__init__(self)
BaseVolume.__init__(self)
self._mapper = vtk.vtkImageResliceMapper()
self._mapper.SliceFacesCameraOn()
self._mapper.SliceAtFocalPointOn()
self._mapper.SetAutoAdjustImageQuality(False)
self._mapper.BorderOff()
self.lut = None
self.property = vtk.vtkImageProperty()
self.property.SetInterpolationTypeToLinear()
self.SetProperty(self.property)
###################
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))
###################
inputtype = str(type(inputobj))
if inputobj is None:
img = vtk.vtkImageData()
if isinstance(inputobj, Volume):
img = inputobj.imagedata()
self.lut = utils.ctf2lut(inputobj)
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 = utils.numpy2vtk(inputobj, dtype=float)
else:
if len(inputobj.shape) > 2:
inputobj = np.transpose(inputobj, axes=[2, 1, 0])
varr = utils.numpy2vtk(inputobj.ravel(order='F'),
dtype=float)
varr.SetName('input_scalars')
img = vtk.vtkImageData()
img.SetDimensions(inputobj.shape)
img.GetPointData().AddArray(varr)
img.GetPointData().SetActiveScalars(varr.GetName())
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("VolumeSlice: cannot understand input type:\n",
inputtype,
c='r')
return
self._data = img
self._mapper.SetInputData(img)
self.SetMapper(self._mapper)
def initView(self, data, widget):
image_type = data.getITKImageType()
self.image = data.getITKImage()
self.space = data.getResolution().tolist()
if len(self.space) == 3:
self.space = [float(x) / self.space[-1] for x in self.space]
self.image.SetSpacing(self.space)
self.rescale_filter = itk.RescaleIntensityImageFilter[image_type, image_type].New()
self.rescale_filter.SetOutputMinimum(0)
self.rescale_filter.SetOutputMaximum(255)
self.rescale_filter.SetInput(self.image)
self.itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New()
self.itk_vtk_converter.SetInput(self.rescale_filter.GetOutput())
self.image_resample = vtk.vtkImageResample()
self.image_resample.SetInput(self.itk_vtk_converter.GetOutput())
data = self.parent.getData()
image_type = data.getITKImageType()
self.image2 = data.getITKImage()
self.space2 = data.getResolution().tolist()
if len(self.space2) == 3:
self.space2 = [float(x) / self.space2[-1] for x in self.space2]
self.image2.SetSpacing(self.space2)
shapeList = data.getData().shape
y, x = shapeList[-2], shapeList[-1]
self.dimension = len(shapeList) == 2
self.rescale_filter2 = itk.RescaleIntensityImageFilter[image_type, image_type].New()
self.rescale_filter2.SetOutputMinimum(0)
self.rescale_filter2.SetOutputMaximum(255)
self.rescale_filter2.SetInput(self.image2)
self.itk_vtk_converter2 = itk.ImageToVTKImageFilter[image_type].New()
self.itk_vtk_converter2.SetInput(self.rescale_filter2.GetOutput())
self.image_resample2 = vtk.vtkImageResample()
self.image_resample2.SetInput(self.itk_vtk_converter2.GetOutput())
self.checkers = vtk.vtkImageCheckerboard()
self.checkers.SetInput1(self.image_resample.GetOutput())
self.checkers.SetInput2(self.image_resample2.GetOutput())
self.division = 3
self.checkers.SetNumberOfDivisions(self.division, self.division, 0)
self.renderer = vtk.vtkRenderer()
self.render_window = widget.GetRenderWindow()
self.render_window.AddRenderer(self.renderer)
self.reslice_mapper = vtk.vtkImageResliceMapper()
self.reslice_mapper.SetInput(self.checkers.GetOutput())
self.reslice_mapper.SliceFacesCameraOn()
self.reslice_mapper.SliceAtFocalPointOn()
self.reslice_mapper.JumpToNearestSliceOn()
self.reslice_mapper.BorderOff()
self.reslice_mapper.BackgroundOn()
array = data.getData()
self.minI = 0
self.maxI = 255
image_property = vtk.vtkImageProperty()
image_property.SetColorWindow(self.maxI - self.minI)
image_property.SetColorLevel((self.maxI + self.minI) / 2.0)
image_property.SetAmbient(0.0)
image_property.SetDiffuse(1.0)
image_property.SetOpacity(1.0)
image_property.SetInterpolationTypeToLinear()
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.reslice_mapper)
self.image_slice.SetProperty(image_property)
self.renderer.AddViewProp(self.image_slice)
self.window_interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImage3D()
self.window_interactor.SetInteractorStyle(self.interactor_style)
self.render_window.SetInteractor(self.window_interactor)
point_picker = vtk.vtkPointPicker()
self.window_interactor.SetPicker(point_picker)
self.render_window.GlobalWarningDisplayOff()
self.render_window.Render()
self.camera = self.renderer.GetActiveCamera()
self.camera.ParallelProjectionOn()
w, h = self.window_interactor.GetSize()
if h * x * self.space[0] < w * y * self.space[1]:
scale = y / 2.0 * self.space[1]
else:
scale = h * x * self.space[0] / 2.0 / w
self.camera.SetParallelScale(scale)
point = self.camera.GetFocalPoint()
dis = self.camera.GetDistance()
self.camera.SetViewUp(0, -1, 0)
self.camera.SetPosition(point[0], point[1], point[2] - dis)
self.renderer.ResetCameraClippingRange()
# View of image
self.view = 2
self.interactor_style.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactor_style.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.interactor_style.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactor_style.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPressCallback)
self.interactor_style.AddObserver("RightButtonPressEvent", self.RightButtonPressCallback)
self.interactor_style.AddObserver("RightButtonReleaseEvent", self.RightButtonReleaseCallback)
self.interactor_style.AddObserver("KeyPressEvent", self.KeyPressCallback)
self.interactor_style.AddObserver("CharEvent", self.CharCallback)
self.updateAfter()
self.render_window.Render()
def initView(self, data, widget):
super(SingleDataView, self).initView(data, widget)
shapeList = data.getData().shape
y, x = shapeList[-2], shapeList[-1]
self.dimension = len(shapeList) == 2
self.reslice_mapper = vtk.vtkImageResliceMapper()
self.reslice_mapper.SetInput(self.image_resample.GetOutput())
self.reslice_mapper.SliceFacesCameraOn()
self.reslice_mapper.SliceAtFocalPointOn()
self.reslice_mapper.JumpToNearestSliceOn()
self.reslice_mapper.BorderOff()
self.reslice_mapper.BackgroundOn()
array = data.getData()
self.minI = array.min()
self.maxI = array.max()
# self.minI = 0
# self.maxI = 255
image_property = vtk.vtkImageProperty()
image_property.SetColorWindow(self.maxI - self.minI)
image_property.SetColorLevel((self.maxI + self.minI) / 2.0)
image_property.SetAmbient(0.0)
image_property.SetDiffuse(1.0)
image_property.SetOpacity(1.0)
image_property.SetInterpolationTypeToLinear()
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.reslice_mapper)
self.image_slice.SetProperty(image_property)
self.renderer.AddViewProp(self.image_slice)
self.window_interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImage3D()
self.window_interactor.SetInteractorStyle(self.interactor_style)
self.render_window.SetInteractor(self.window_interactor)
point_picker = vtk.vtkPointPicker()
self.window_interactor.SetPicker(point_picker)
self.render_window.GlobalWarningDisplayOff()
self.render_window.Render()
self.camera = self.renderer.GetActiveCamera()
self.camera.ParallelProjectionOn()
w, h = self.window_interactor.GetSize()
if h * x * self.space[0] < w * y * self.space[1]:
scale = y / 2.0 * self.space[1]
else:
scale = h * x * self.space[0] / 2.0 / w
self.camera.SetParallelScale(scale)
point = self.camera.GetFocalPoint()
dis = self.camera.GetDistance()
self.camera.SetViewUp(0, -1, 0)
self.camera.SetPosition(point[0], point[1], point[2] - dis)
self.renderer.ResetCameraClippingRange()
# View of image
self.view = 2
self.interactor_style.AddObserver("MouseMoveEvent",
self.MouseMoveCallback)
self.interactor_style.AddObserver("LeftButtonReleaseEvent",
self.LeftButtonReleaseCallback)
self.interactor_style.AddObserver("LeftButtonPressEvent",
self.LeftButtonPressCallback)
self.interactor_style.AddObserver("MiddleButtonPressEvent",
self.MiddleButtonPressCallback)
self.interactor_style.AddObserver("RightButtonPressEvent",
self.RightButtonPressCallback)
self.interactor_style.AddObserver("RightButtonReleaseEvent",
self.RightButtonReleaseCallback)
self.interactor_style.AddObserver("KeyPressEvent",
self.KeyPressCallback)
self.interactor_style.AddObserver("CharEvent", self.CharCallback)
#self.plugin[0].enable(self)
self.updateAfter()
self.render_window.Render()
def initView(self, data, widget):
super(SingleDataView, self).initView(data, widget)
shapeList = data.getData().shape
y, x = shapeList[-2], shapeList[-1]
self.dimension = len(shapeList) == 2
self.reslice_mapper = vtk.vtkImageResliceMapper()
self.reslice_mapper.SetInput(self.image_resample.GetOutput())
self.reslice_mapper.SliceFacesCameraOn()
self.reslice_mapper.SliceAtFocalPointOn()
self.reslice_mapper.JumpToNearestSliceOn()
self.reslice_mapper.BorderOff()
self.reslice_mapper.BackgroundOn()
array = data.getData()
self.minI = array.min()
self.maxI = array.max()
# self.minI = 0
# self.maxI = 255
image_property = vtk.vtkImageProperty()
image_property.SetColorWindow(self.maxI - self.minI)
image_property.SetColorLevel((self.maxI + self.minI) / 2.0)
image_property.SetAmbient(0.0)
image_property.SetDiffuse(1.0)
image_property.SetOpacity(1.0)
image_property.SetInterpolationTypeToLinear()
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.reslice_mapper)
self.image_slice.SetProperty(image_property)
self.renderer.AddViewProp(self.image_slice)
self.window_interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImage3D()
self.window_interactor.SetInteractorStyle(self.interactor_style)
self.render_window.SetInteractor(self.window_interactor)
point_picker = vtk.vtkPointPicker()
self.window_interactor.SetPicker(point_picker)
self.render_window.GlobalWarningDisplayOff()
self.render_window.Render()
self.camera = self.renderer.GetActiveCamera()
self.camera.ParallelProjectionOn()
w, h = self.window_interactor.GetSize()
if h * x * self.space[0] < w * y * self.space[1]:
scale = y / 2.0 * self.space[1]
else:
scale = h * x * self.space[0] / 2.0 / w
self.camera.SetParallelScale(scale)
point = self.camera.GetFocalPoint()
dis = self.camera.GetDistance()
self.camera.SetViewUp(0, -1, 0)
self.camera.SetPosition(point[0], point[1], point[2] - dis)
self.renderer.ResetCameraClippingRange()
# View of image
self.view = 2
self.interactor_style.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactor_style.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.interactor_style.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactor_style.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPressCallback)
self.interactor_style.AddObserver("RightButtonPressEvent", self.RightButtonPressCallback)
self.interactor_style.AddObserver("RightButtonReleaseEvent", self.RightButtonReleaseCallback)
self.interactor_style.AddObserver("KeyPressEvent", self.KeyPressCallback)
self.interactor_style.AddObserver("CharEvent", self.CharCallback)
#self.plugin[0].enable(self)
self.updateAfter()
self.render_window.Render()
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.renderer, self.frame, self.vtk_widget, self.interactor, self.render_window = self.setup(
)
self.brain = NiiObject()
self.brain.settings = NiiSettings(BRAIN_FILE, BRAIN_COLOR,
BRAIN_OPACITY, BRAIN_THRESHOLD,
BRAIN_SMOOTHNESS)
add_mri_object(self.renderer, self.render_window, self.brain)
self.tumor = NiiObject()
self.tumor.settings = NiiSettings(TUMOR_FILE, TUMOR_COLOR,
TUMOR_OPACITY, TUMOR_THRESHOLD,
TUMOR_SMOOTHNESS)
add_mri_object(self.renderer, self.render_window, self.tumor)
slice_mapper = vtk.vtkImageResliceMapper()
slice_mapper.SetInputConnection(self.brain.reader.GetOutputPort())
slice_mapper.SliceFacesCameraOn()
slice_mapper.SliceAtFocalPointOn()
slice_mapper.BorderOff()
self.brain_image_prop = vtk.vtkImageProperty()
self.brain_image_prop.SetColorWindow(500)
self.brain_image_prop.SetColorLevel(500)
self.brain_image_prop.SetAmbient(1.0)
self.brain_image_prop.SetDiffuse(1.0)
self.brain_image_prop.SetOpacity(0.0)
self.brain_image_prop.SetInterpolationTypeToLinear()
image_slice = vtk.vtkImageSlice()
image_slice.SetMapper(slice_mapper)
image_slice.SetProperty(self.brain_image_prop)
self.renderer.AddViewProp(image_slice)
self.grid = QtWidgets.QGridLayout()
self.form = QtWidgets.QFormLayout()
self.form.setAlignment(Qt.Qt.AlignLeft)
# brain pickers
self.brain_threshold_sp = self.add_brain_threshold_picker()
self.brain_opacity_sp = self.add_brain_opacity_picker()
self.brain_smoothness_sp = self.add_brain_smoothness_picker()
# tumor pickers
self.tumor_threshold_sp = self.add_tumor_threshold_picker()
self.tumor_opacity_sp = self.add_tumor_opacity_picker()
self.tumor_smoothness_sp = self.add_tumor_smoothness_picker()
# add pickers to layout
self.grid.addItem(self.form, 0, 0)
self.grid.addWidget(self.vtk_widget, 0, 1)
# add to brain form
self.form.addRow(QtWidgets.QLabel("Brain Threshold"),
self.brain_threshold_sp)
self.form.addRow(QtWidgets.QLabel("Brain Opacity"),
self.brain_opacity_sp)
self.form.addRow(QtWidgets.QLabel("Brain Smoothness"),
self.brain_smoothness_sp)
# add to tumor form
self.form.addRow(QtWidgets.QLabel("Tumor Threshold"),
self.tumor_threshold_sp)
self.form.addRow(QtWidgets.QLabel("Tumor Opacity"),
self.tumor_opacity_sp)
self.form.addRow(QtWidgets.QLabel("Tumor Smoothness"),
self.tumor_smoothness_sp)
self.form.setLabelAlignment(Qt.Qt.AlignLeft)
self.form.setFormAlignment(Qt.Qt.AlignRight)
self.form.setSpacing(5)
self.brain_projection_cb = self.add_brain_projection()
self.form.addRow(QtWidgets.QLabel("Show Projection"),
self.brain_projection_cb)
# set layout and show
self.setWindowTitle("3D Nifti Visualizer")
self.frame.setLayout(self.grid)
self.setCentralWidget(self.frame)
self.show()
self.interactor.Initialize()
