def __init__(self, Mgr):
self.Mgr = Mgr
self.m_volumeInfo = None
self.m_selectedIdx = None
self.m_selectedImage = None
# self.m_reverseSagittal = False
# self.m_reverseAxial = False
self.m_shoulderSide = 'L'
self.m_orientation = None ##AXL:1, COR:0, SAG:2
#Selected Volume CFGS
self.m_colorFunction = vtk.vtkColorTransferFunction()
self.m_opacityFunction = vtk.vtkPiecewiseFunction()
self.m_scalarRange = [0.0, 1.0]
self.m_volumeProperty = vtk.vtkVolumeProperty()
self.m_imageProperty = vtk.vtkImageProperty()
self.m_imageProperty.SetInterpolationTypeToLinear()
#Volume
self.volume_data = vtk.vtkImageData()
self.volume_cropper = vtk.vtkImageData()
self.m_volumeMapper = vtk.vtkSmartVolumeMapper()
self.m_volume = vtk.vtkVolume()
self.m_resliceMapper = [0, 0, 0]
self.m_resliceActor = [0, 0, 0]
#Color MAp Volume
self.m_bShowCAM = False
self.m_bShowVolume = False
self.m_colorMapMapper = vtk.vtkSmartVolumeMapper()
self.m_colorMapVolume = vtk.vtkVolume()
self.m_colorMapResliceMapper = [None, None, None]
self.m_colorMapResliceActor = [None, None, None]
self.resolution = 64
#Crop View
self.croppingMapper = vtk.vtkImageSliceMapper()
self.croppingActor = vtk.vtkImageSlice()
for i in range(3):
self.m_resliceMapper[i] = vtk.vtkImageSliceMapper()
self.m_resliceActor[i] = vtk.vtkImageSlice()
self.m_colorMapResliceMapper[i] = vtk.vtkImageSliceMapper()
self.m_colorMapResliceActor[i] = vtk.vtkImageSlice()
self.m_resliceActor[0].RotateY(90)
self.m_resliceActor[1].RotateX(-90)
self.m_colorMapResliceActor[0].RotateY(90)
self.m_colorMapResliceActor[1].RotateX(-90)
#Initialize
self.SetPresetFunctions(
self.Mgr.mainFrm.volumeWidget.GetCurrentColorIndex())
self.InitializeVolumeFunctions()
self.InitializeClassActivationMap()
def __init__(self):
super(DualFlouroSceneVisualizer, self).__init__()
# Remove origin information
self.xray_changer_1 = vtk.vtkImageChangeInformation()
self.xray_changer_1.SetOutputOrigin(0, 0, 0)
self.xray_changer_2 = vtk.vtkImageChangeInformation()
self.xray_changer_2.SetOutputOrigin(0, 0, 0)
self.ct_changer = vtk.vtkImageChangeInformation()
self.ct_changer.SetOutputOrigin(0, 0, 0)
# Setup mapper and actor for x-ray images
self.xray_mapper_1 = vtk.vtkImageSliceMapper()
self.xray_mapper_1.SetInputConnection(
self.xray_changer_1.GetOutputPort())
self.xray_mapper_2 = vtk.vtkImageSliceMapper()
self.xray_mapper_2.SetInputConnection(
self.xray_changer_2.GetOutputPort())
self.xray_property = vtk.vtkImageProperty()
self.xray_property.SetInterpolationTypeToNearest()
self.xray_slice_1 = vtk.vtkImageSlice()
self.xray_slice_1.SetMapper(self.xray_mapper_1)
self.xray_slice_1.SetProperty(self.xray_property)
self.xray_slice_2 = vtk.vtkImageSlice()
self.xray_slice_2.SetMapper(self.xray_mapper_2)
self.xray_slice_2.SetProperty(self.xray_property)
self.marchingCubes = vtk.vtkImageMarchingCubes()
self.marchingCubes.SetInputConnection(self.ct_changer.GetOutputPort())
self.marchingCubes.ComputeGradientsOn()
self.marchingCubes.ComputeNormalsOn()
self.marchingCubes.ComputeScalarsOn()
self.marchingCubes.SetNumberOfContours(1)
self.marchingCubes.SetValue(0, 0)
self.ct_mapper = vtk.vtkPolyDataMapper()
self.ct_mapper.SetInputConnection(self.marchingCubes.GetOutputPort())
self.ct_mapper.ScalarVisibilityOff()
self.ct_actor = vtk.vtkActor()
self.ct_actor.SetMapper(self.ct_mapper)
self.ct_actor.GetProperty().SetInterpolationToGouraud()
self.ct_actor.GetProperty().SetColor(GetRGBColor('antique_white'))
self.renderer = vtk.vtkRenderer()
self.renderer.AddViewProp(self.ct_actor)
self.renderer.AddViewProp(self.xray_slice_1)
self.renderer.AddViewProp(self.xray_slice_2)
self.renderer.SetBackground(0.1, 0.2, 0.3)
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleTrackballCamera()
self.interactor.SetInteractorStyle(self.interactor_style)
def __init__(self):
super(ImageSliceVisualizer, self).__init__()
# Setup pipeline
self.image_mapper = vtk.vtkImageSliceMapper()
self.image_mapper.SliceAtFocalPointOn()
self.image_mapper.SliceFacesCameraOn()
self.image_property = vtk.vtkImageProperty()
self.image_property.SetInterpolationTypeToNearest()
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.image_mapper)
self.image_slice.SetProperty(self.image_property)
self.renderer = vtk.vtkRenderer()
self.renderer.AddActor2D(self.image_slice)
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor_style = vtk.vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImageSlicing()
self.interactor_style.KeyPressActivationOn()
self.interactor.SetInteractorStyle(self.interactor_style)
# Add ability to switch between active layers
self.interactor.AddObserver('KeyPressEvent',
self._interactor_call_back, -1.0)
def addSliceZ(self):
if not (self.toggleThreeSlicesFlag):
return
if not (self.Slices[2] == None):
self.renderer.RemoveActor(self.Slices[2])
self.Slices[2] = None
self.map3 = vtk.vtkImageSliceMapper()
self.map3.BorderOn()
self.map3.SliceAtFocalPointOff()
self.map3.SliceFacesCameraOff()
self.map3.SetOrientationToZ()
if vtk.VTK_MAJOR_VERSION <= 5:
self.map3.SetInput(self.TemplateReader.GetOutput())
else:
self.map3.SetInputConnection(self.TemplateReader.GetOutputPort())
self.map3.SetSliceNumber(0)
slice1 = vtk.vtkImageSlice()
slice1.SetMapper(self.map3)
slice1.GetProperty().SetColorWindow(self.vrange[1] - self.vrange[0])
slice1.GetProperty().SetColorLevel(0.5 *
(self.vrange[0] + self.vrange[1]))
self.Slices[2] = slice1
self.renderer.AddViewProp(slice1)
self.renderWin.GetInteractor().Render()
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.dicom_image_path = './IM-0008-0034.dcm'
# '----------set up dicom reader---------------'
self.dcmReader = vtk.vtkDICOMImageReader()
self.dcmReader.SetDataByteOrderToLittleEndian()
self.dcmReader.SetDirectoryName(
r"D:\Users\user\Desktop\NTUCT\1323\Ct_Without_ContrastBrain - 1323\InnerEar_C_06_U70u_4"
)
self.dcmReader.Update()
# '----------init render---------------'
self.ren = vtk.vtkRenderer()
# '---------set up mapper----------'
self.slice_mapper = vtk.vtkImageSliceMapper()
self.slice_mapper.SetInputConnection(self.dcmReader.GetOutputPort())
# set random slice number
# self.slice_mapper.SetSliceNumber(50)
# set up image_slice
self.image_slice = vtk.vtkImageSlice()
self.image_slice.SetMapper(self.slice_mapper)
# '-----set up window and level of image_slice----'
# self.MinMax = self.dcmReader.GetOutput().GetScalarRange()
# self.image_slice_property = self.image_slice.GetProperty()
# self.image_slice_property.SetColorWindow(self.MinMax[1])
# self.image_slice_property.SetColorLevel((self.MinMax[1] - self.MinMax[0]) / 2)
# self.image_slice.Update()
# '---------set image_slice as input for renderer------'
self.ren.AddViewProp(self.image_slice)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(self.dcmReader.GetOutputPort())
# # Create an actor
# actor = vtk.vtkActor()
# actor.SetMapper(mapper)
# self.ren.AddActor(actor)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
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 build(self):
actor = vtk.vtkImageSlice()
actor.SetMapper(self._mapper)
actor.SetProperty(self._property)
if self._transform is not None:
actor.SetUserTransform(self._transform)
actor.Update()
return actor
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 image(file):
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(file)
reader.Update()
middle = 115
min = 0
max = 255
t = threshold(reader, 10, min, max)
mapper = vtk.vtkImageSliceMapper()
mapper.SliceAtFocalPointOn()
mapper.SetInputConnection(t.GetOutputPort())
actor = vtk.vtkImageSlice()
actor.SetMapper(mapper)
return actor
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 __init__(self):
self.colour = (0.0, 0.0, 1.0)
self.opacity = 1
self.size = 15.0
self.orientation = "AXIAL"
self.spacing = (1, 1, 1)
if vtk.vtkVersion().GetVTKVersion() > '5.8.0':
self.mapper = vtk.vtkImageSliceMapper()
cursor_property = vtk.vtkImageProperty()
cursor_property.SetInterpolationTypeToNearest()
self.actor = vtk.vtkImageSlice()
self.actor.SetMapper(self.mapper)
self.actor.SetProperty(cursor_property)
else:
self.actor = vtk.vtkImageActor()
self.mapper = None
self._build_actor()
self._calculate_area_pixels()
def AddViewProp(self, prop):
rotateProp = vtk.vtkImageSlice()
rotateProp.SetMapper(prop.GetMapper())
rotateProp.SetProperty(prop.GetProperty())
if self.viewType == 'AXL':
rotateProp.RotateX(-90)
elif self.viewType == 'SAG':
rotateProp.RotateY(90)
bounds = [
rotateProp.GetMaxXBound(),
rotateProp.GetMaxYBound(),
rotateProp.GetMaxZBound()
]
super(E_SliceRenderer, self).AddViewProp(rotateProp)
self.AddGuide(bounds)
def __init__(self):
self.colour = (0.0, 0.0, 1.0)
self.opacity = 1
self.size = 15.0
self.orientation = "AXIAL"
self.spacing = (1, 1, 1)
self.position = (0, 0, 0)
if vtk.vtkVersion().GetVTKVersion() > '5.8.0':
self.mapper = vtk.vtkImageSliceMapper()
cursor_property = vtk.vtkImageProperty()
cursor_property.SetInterpolationTypeToNearest()
self.actor = vtk.vtkImageSlice()
self.actor.SetMapper(self.mapper)
self.actor.SetProperty(cursor_property)
else:
self.actor = vtk.vtkImageActor()
self.mapper = None
self._build_actor()
self._calculate_area_pixels()
def open_File(self):
self.reader = vtk.vtkNIFTIImageReader()
self.reader.SetFileName('brain1.nii')
self.reader.Update()
#Data Processing
self.size = self.reader.GetOutput().GetDimensions()
center = self.reader.GetOutput().GetCenter()
spacing = self.reader.GetOutput().GetSpacing()
print('size:' + str(self.size))
print('center:' + str(center))
self.center_cam = (center[0], center[1], center[2])
#Get graysacle Range
vrange = self.reader.GetOutput().GetScalarRange()
#Set Image Slicer Mappers for each view
self.map = vtk.vtkImageSliceMapper()
self.map.BorderOn()
self.map.SliceAtFocalPointOn()
self.map.SliceFacesCameraOn()
self.map.SetInputConnection(self.reader.GetOutputPort())
self.slice = vtk.vtkImageSlice()
self.slice.SetMapper(self.map)
self.slice.GetProperty().SetColorWindow(vrange[1] - vrange[0])
self.slice.GetProperty().SetColorLevel(0.5 * (vrange[0] + vrange[1]))
self.ren.AddActor(self.slice)
self.cam = self.ren.GetActiveCamera()
self.cam.ParallelProjectionOn()
self.cam.SetParallelScale(0.5 * spacing[1] * self.size[1])
self.cam.SetFocalPoint(self.center_cam[0], self.center_cam[1],
self.center_cam[2])
print(self.center_cam)
self.changeView()
self.spinBox.setEnabled(True)
def updateSliceZ(self):
if not (self.toggleThreeSlicesFlag):
return
if not (self.Slices[2] == None):
self.renderer.RemoveActor(self.Slices[2])
self.Slices[2] = None
self.map3.SetSliceNumber(self.SetZAxisValues)
slice1 = vtk.vtkImageSlice()
slice1.SetMapper(self.map3)
slice1.GetProperty().SetColorWindow(self.vrange[1] - self.vrange[0])
slice1.GetProperty().SetColorLevel(0.5 *
(self.vrange[0] + self.vrange[1]))
self.Slices[2] = slice1
self.renderer.AddViewProp(slice1)
self.renderWin.GetInteractor().Render()
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 __init__(self, parent=None):
Qt.QMainWindow.__init__(self, parent)
self.frame = Qt.QFrame()
self.vl = Qt.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.sl = Qt.QSlider()
self.sl.setMinimum(1.0)
self.sl.setMaximum(200.0)
self.sl.setValue(50.0)
self.vl.addWidget(self.sl)
self.sl.valueChanged.connect(self.valuechange)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImageSlicing()
self.iren.SetInteractorStyle(style)
# Read the image
self.reader = vtk.vtkNIFTIImageReader()
self.reader.SetFileName('brain1.nii')
self.reader.Update()
# SLICE Mapper :-)
self.map = vtk.vtkImageSliceMapper()
self.map.SetSliceNumber(50)
self.map.SetInputConnection(self.reader.GetOutputPort())
# Put mapper into actor and actor into renderer
slice = vtk.vtkImageSlice()
slice.SetMapper(self.map)
self.ren.AddActor(slice)
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
image2.SetDrawColor(0,255,255) image2.FillBox(0,size,0,size) pad2 = vtk.vtkImageWrapPad() pad2.SetInputConnection(image2.GetOutputPort()) pad2.SetOutputWholeExtent(0,size,0,size,0,10) pad2.Update() checkers = vtk.vtkImageCheckerboard() checkers.SetInput1Data(pad1.GetOutput()) checkers.SetInput2Data(pad2.GetOutput()) checkers.SetNumberOfDivisions(11,6,0) mapper=vtk.vtkImageSliceMapper() mapper.SetInputConnection(checkers.GetOutputPort()) mapper.SliceAtFocalPointOn() mapper.SliceFacesCameraOn() imageSlice = vtk.vtkImageSlice() imageSlice.SetMapper(mapper) imageSlice.GetProperty().SetColorLevel(127.5) imageSlice.GetProperty().SetColorWindow(255) renderer=vtk.vtkRenderer() renderer.AddViewProp(imageSlice) window=vtk.vtkRenderWindow() window.SetSize(size,size) window.AddRenderer(renderer) window.Render() pp = vtk.vtkPointPicker() cp = vtk.vtkCellPicker() p = vtk.vtkPicker() errors = 0
ip.SetOpacity(1.0)
ip.SetInterpolationTypeToLinear()
bounds = im.GetBounds()
print bounds
point = [0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5])]
print point
camera = ren1.GetActiveCamera()
camera.SetFocalPoint(point)
point[2] += 50.0
camera.SetPosition(point)
camera.ParallelProjectionOn()
camera.SetParallelScale(5.0)
ia = vtk.vtkImageSlice()
ia.SetMapper(im)
ia.SetProperty(ip)
ren1.AddViewProp(ia)
ren1.SetBackground(0.1, 0.2, 0.4)
renWin.SetSize(300, 300)
def CharCallback(obj, event):
iren = renWin.GetInteractor()
keycode = iren.GetKeyCode()
if keycode == "s":
# style.StartSpin();
style.StartWindowLevel()
return
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) input1Slice = vtk.vtkImageSlice() input1Slice.SetMapper(input1Mapper) input1Slice.SetProperty(image1Property) # Setup input2 Mapper + Property -> Slice input2Mapper = vtk.vtkImageResliceMapper() input2Mapper.SetInputConnection(reader2.GetOutputPort()) input2Mapper.SliceAtFocalPointOn() input2Mapper.SliceFacesCameraOn() input2Mapper.BorderOff() input2Mapper.SetNumberOfThreads(args.nThreads) input2Mapper.ResampleToScreenPixelsOn() input2Mapper.StreamingOn() image2Property = vtk.vtkImageProperty() image2Property.SetColorLevel(level[1])
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() inputSlice.SetMapper(inputMapper) inputSlice.SetProperty(imageProperty) # Setup seg Mapper + Property -> Slice segImageProperty = vtk.vtkImageProperty() segImageProperty.SetLookupTable(segLUT) segImageProperty.UseLookupTableScalarRangeOn() segImageProperty.SetInterpolationTypeToLinear() segImageProperty.SetOpacity(args.opacity) segImageProperty.SetLayerNumber(2) segImageProperty.SetInterpolationTypeToNearest() segMapper = vtk.vtkImageResliceMapper() segMapper.SetInputConnection(segReader.GetOutputPort()) segMapper.SliceAtFocalPointOn()
def slice_view(image,
index,
width,
height,
zdir=2,
polydata=[],
colors=default_colors,
transform=None,
line_width=3,
level_window=None,
image_lut=None,
interpolation="nearest"):
"""Return vtkRenderer for orthogonal image slice."""
# determine orientation of medical volume
flip = [False, False, False]
if transform:
transform.Update()
matrix = deep_copy(transform.GetMatrix())
try:
from nibabel import aff2axcodes
codes = aff2axcodes(matrix_to_affine(matrix))
except Exception:
codes = ('L', 'A', 'S')
if matrix.GetElement(0, 0) < 0:
codes = 'R'
if matrix.GetElement(1, 1) < 0:
codes = 'P'
if matrix.GetElement(2, 2) < 0:
codes = 'I'
if codes[0] == 'R':
flip[0] = True
if codes[1] == 'P':
flip[1] = True
if codes[2] == 'I':
flip[2] = True
dims = image.GetDimensions()
axes = slice_axes(zdir)
if width < 1:
width = dims[axes[0]]
if height < 1:
height = dims[axes[1]]
size = [1, 1, 1]
size[axes[0]] = width
size[axes[1]] = height
if zdir == 2:
up = (0, 1, 0)
else:
up = (0, 0, 1)
spacing = image.GetSpacing()
distance = 10. * spacing[zdir]
focal_point = index_to_point(index, image.GetOrigin(), spacing)
position = list(focal_point)
if flip[zdir]:
position[zdir] = position[zdir] - distance
else:
position[zdir] = position[zdir] + distance
margin = 2
extent = cropping_region(index, axes, size[axes[0]] + margin,
size[axes[1]] + margin)
if flip[0] or flip[1] or flip[2]:
flip_transform = vtk.vtkTransform()
flip_transform.Translate(+focal_point[0], +focal_point[1],
+focal_point[2])
flip_transform.Scale(-1. if flip[0] else 1., -1. if flip[1] else 1.,
-1. if flip[2] else 1.)
flip_transform.Translate(-focal_point[0], -focal_point[1],
-focal_point[2])
points_transform = vtk.vtkTransform()
points_transform.SetMatrix(matrix)
points_transform.PostMultiply()
points_transform.Concatenate(flip_transform)
else:
flip_transform = None
points_transform = None
mapper = vtk.vtkImageSliceMapper()
mapper.SetInputData(image)
mapper.SetOrientation(zdir)
mapper.SetSliceNumber(extent[2 * zdir])
mapper.SetCroppingRegion(extent)
mapper.CroppingOn()
mapper.Update()
actor = vtk.vtkImageSlice()
actor.SetMapper(mapper)
if flip_transform:
actor.SetUserTransform(flip_transform)
prop = actor.GetProperty()
interpolation = interpolation.lower()
if interpolation in ("nn", "nearest"):
prop.SetInterpolationTypeToNearest()
elif interpolation == "linear":
prop.SetInterpolationTypeToLinear()
elif interpolation == "cubic":
prop.SetInterpolationTypeToCubic()
else:
raise ValueError(
"Invalid interpolation mode: {}".format(interpolation))
if not level_window:
level_window = auto_level_window(image)
prop.SetColorLevel(level_window[0])
prop.SetColorWindow(level_window[1])
if image_lut:
prop.SetLookupTable(image_lut)
prop.UseLookupTableScalarRangeOn()
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
camera = renderer.GetActiveCamera()
camera.SetViewUp(up)
camera.SetPosition(position)
camera.SetFocalPoint(focal_point)
camera.SetParallelScale(.5 * max((size[axes[0]] - 1) * spacing[axes[0]],
(size[axes[1]] - 1) * spacing[axes[1]]))
camera.SetClippingRange(distance - .5 * spacing[zdir],
distance + .5 * spacing[zdir])
camera.ParallelProjectionOn()
# add contours of polygonal data intersected by slice plane
if isinstance(polydata, vtk.vtkPolyData):
polydata = [polydata]
if isinstance(line_width, int):
line_width = [line_width]
if isinstance(colors[0], float):
colors = [colors]
for i in xrange(len(polydata)):
if i < len(colors):
color = colors[i]
else:
color = colors[-1]
if i < len(line_width):
width = line_width[i]
else:
width = line_width[-1]
add_contour(renderer,
plane=mapper.GetSlicePlane(),
polydata=polydata[i],
transform=points_transform,
line_width=width,
color=color)
return renderer
volume_prop.SetColor(color_func)
volume_prop.SetScalarOpacity(opac_func)
volume_actor.SetMapper(volume_mapper)
volume_actor.SetProperty(volume_prop)
volume_actor.SetPosition([0, 0, 0])
volume_prop.ShadeOff()
volume_prop.SetInterpolationTypeToLinear()
volume_mapper.SetBlendModeToMaximumIntensity()
image_prop = vtk.vtkImageProperty()
slice_mapper = []
slice_actor = []
for i in range(3):
slice_mapper.append(vtk.vtkImageSliceMapper())
slice_mapper[i].BorderOn()
slice_actor.append(vtk.vtkImageSlice())
slice_mapper[i].SetOrientation(i)
slice_actor[i].SetMapper(slice_mapper[i])
slice_actor[i].SetProperty(image_prop)
def get_tmp_data():
return tmp_data
def save_tmp_data():
np.savez_compressed(tmp_path, data=tmp_data, time=elapsed_time)
def get_volume(idx=None):
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) ia.SetProperty(ip) ren1.AddViewProp(ia) ren1.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(300, 300) iren = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleImage() style.SetInteractionModeToImage3D() iren.SetInteractorStyle(style) renWin.SetInteractor(iren) # render the image renWin.Render()
gridReader.Update() # Setup input Mapper + Property -> Slice inputMapper = vtk.vtkImageSliceMapper() inputMapper.SetInputConnection(inputReader.GetOutputPort()) inputMapper.SliceAtFocalPointOn() inputMapper.SliceFacesCameraOn() inputMapper.BorderOff() imageProperty = vtk.vtkImageProperty() imageProperty.SetColorLevel(args.level) imageProperty.SetColorWindow(args.window) imageProperty.SetInterpolationTypeToLinear() imageProperty.SetLayerNumber(1) inputSlice = vtk.vtkImageSlice() inputSlice.SetMapper(inputMapper) inputSlice.SetProperty(imageProperty) # Determine an appropriate window/level for the grid scalarRange = [int(x) for x in gridReader.GetOutput().GetScalarRange()] window = scalarRange[1] - scalarRange[0]+1 level = (scalarRange[1] + scalarRange[0])/2 # Setup grid Mapper + Property -> Slice gridImageProperty = vtk.vtkImageProperty() gridImageProperty.SetOpacity(args.opacity) gridImageProperty.SetColorLevel(level) gridImageProperty.SetColorWindow(window) gridImageProperty.SetLayerNumber(2) gridImageProperty.SetInterpolationTypeToNearest()
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 TestDisplay(file1):
"""Display the output"""
inpath = os.path.join(str(VTK_DATA_ROOT), "Data", file1)
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(inpath)
reader.Update()
size = reader.GetOutput().GetDimensions()
center = reader.GetOutput().GetCenter()
spacing = reader.GetOutput().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 = reader.GetOutput().GetScalarRange()
map1 = vtk.vtkImageSliceMapper()
map1.BorderOn()
map1.SliceAtFocalPointOn()
map1.SliceFacesCameraOn()
map1.SetInputConnection(reader.GetOutputPort())
map2 = vtk.vtkImageSliceMapper()
map2.BorderOn()
map2.SliceAtFocalPointOn()
map2.SliceFacesCameraOn()
map2.SetInputConnection(reader.GetOutputPort())
slice1 = vtk.vtkImageSlice()
slice1.SetMapper(map1)
slice1.GetProperty().SetColorWindow(vrange[1]-vrange[0])
slice1.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1]))
slice2 = vtk.vtkImageSlice()
slice2.SetMapper(map2)
slice2.GetProperty().SetColorWindow(vrange[1]-vrange[0])
slice2.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1]))
ratio = size[0]*1.0/(size[0]+size[2])
ren1 = vtk.vtkRenderer()
ren1.SetViewport(0,0,ratio,1.0)
ren2 = vtk.vtkRenderer()
ren2.SetViewport(ratio,0.0,1.0,1.0)
ren1.AddViewProp(slice1)
ren2.AddViewProp(slice2)
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])
if "-I" in sys.argv:
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImageSlicing()
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(style)
renwin = vtk.vtkRenderWindow()
renwin.SetSize(size[0] + size[2], size[1])
renwin.AddRenderer(ren1)
renwin.AddRenderer(ren2)
renwin.Render()
if "-I" in sys.argv:
renwin.SetInteractor(iren)
iren.Initialize()
iren.Start()
return renwin
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()
dens0.ComputeGradientOn()
dens0.Update()
vrange = dens0.GetOutput().GetPointData().GetArray("Gradient Magnitude").GetRange()
# Show the gradient magnitude
assign0 = vtk.vtkAssignAttribute()
assign0.SetInputConnection(dens0.GetOutputPort())
assign0.Assign("Gradient Magnitude", "SCALARS", "POINT_DATA")
map0 = vtk.vtkImageSliceMapper()
map0.BorderOn()
map0.SliceAtFocalPointOn()
map0.SliceFacesCameraOn()
map0.SetInputConnection(assign0.GetOutputPort())
slice0 = vtk.vtkImageSlice()
slice0.SetMapper(map0)
slice0.GetProperty().SetColorWindow(vrange[1]-vrange[0])
slice0.GetProperty().SetColorLevel(0.5*(vrange[0]+vrange[1]))
# Show the region labels
assign1 = vtk.vtkAssignAttribute()
assign1.SetInputConnection(dens0.GetOutputPort())
assign1.Assign("Classification", "SCALARS", "POINT_DATA")
map1 = vtk.vtkImageSliceMapper()
map1.BorderOn()
map1.SliceAtFocalPointOn()
map1.SliceFacesCameraOn()
map1.SetInputConnection(assign1.GetOutputPort())
map1.Update()
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 ToggleDRR(self, value):
if self.DRRInitialized == True:
if value == True:
self.image.VisibilityOn()
self.toggleDRR = True
self.slicerRenderer.Render()
return
self.image.VisibilityOff()
self.toggleDRR = False
self.slicerRenderer.Render()
return
self.DRRInitialized = True
self.toggleDRR = True
# Initialize Window To Input Pipeline
self.cameraTransform = vtk.vtkTransform()
self.xRotationValue = 0.0
self.zRotationValue = 0.0
self.winToImage = vtk.vtkWindowToImageFilter()
self.pixelData = vtk.vtkImageData()
self.winToImage.SetInput(self.renderWindow)
self.imageMapper = vtk.vtkImageSliceMapper()
self.image = vtk.vtkImageSlice()
self.imageMapper.SetInputData(self.winToImage.GetOutput())
self.image.SetMapper(self.imageMapper)
# Render DRR (replace with udpate DRR)
self.cameraTransform.Identity()
self.cameraTransform.PostMultiply()
self.cameraTransform.Translate(0, 705.81, 0)
self.cameraTransform.RotateZ(self.zRotationValue)
self.cameraTransform.RotateX(-self.xRotationValue)
self.renderer.GetActiveCamera().SetPosition(
self.cameraTransform.GetPosition())
self.renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
self.renderer.GetActiveCamera().SetViewUp(0, 0, 1)
self.renderer.SetBackground(1, 1, 1)
self.renderWindow.Render()
self.winToImage = vtk.vtkWindowToImageFilter()
self.winToImage.SetInput(self.renderWindow)
self.winToImage.Update()
# Add DRR Image to Scene using vtkPlaneSource
self.plane = vtk.vtkPlaneSource()
#self.texture = vtk.vtkTexture()
#self.texture.SetInputConnection(self.winToImage.GetOutputPort())
#self.texture.Update()
#self.plane.SetPoint1(0, 530, 0)
self.plane.SetPoint1(0, 1060, 0)
#self.plane.SetPoint2(335, 0, 0)
self.plane.SetPoint2(675, 0, 0)
self.plane.SetOrigin(0, 0, 0)
self.plane.Update()
# Create DRR Model Node
self.planeModelNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLModelNode')
self.planeModelNode.CreateDefaultDisplayNodes()
#self.planeModelNode.CreateDefaultStorageNode()
self.planeModelNode.SetAndObservePolyData(self.plane.GetOutput())
self.planeModelNode.SetAndObserveTransformNodeID(
self.scene.dRRToMonitorTransform.GetID())
self.planeModelDisplay = self.planeModelNode.GetDisplayNode()
self.planeModelDisplay.SetTextureImageDataConnection(
self.winToImage.GetOutputPort())
self.planeModelDisplay.VisibilityOn()
self.planeModelDisplay.SetFrontfaceCulling(False)
self.planeModelDisplay.SetBackfaceCulling(False)
self.renderWindow.Render()
self.slicerRenderer.Render()
dens0.ComputeGradientOn()
dens0.Update()
vrange = dens0.GetOutput().GetPointData().GetArray("Gradient Magnitude").GetRange()
# Show the gradient magnitude
assign0 = vtk.vtkAssignAttribute()
assign0.SetInputConnection(dens0.GetOutputPort())
assign0.Assign("Gradient Magnitude", "SCALARS", "POINT_DATA")
map0 = vtk.vtkImageSliceMapper()
map0.BorderOn()
map0.SliceAtFocalPointOn()
map0.SliceFacesCameraOn()
map0.SetInputConnection(assign0.GetOutputPort())
slice0 = vtk.vtkImageSlice()
slice0.SetMapper(map0)
slice0.GetProperty().SetColorWindow(vrange[1] - vrange[0])
slice0.GetProperty().SetColorLevel(0.5 * (vrange[0] + vrange[1]))
# Show the region labels
assign1 = vtk.vtkAssignAttribute()
assign1.SetInputConnection(dens0.GetOutputPort())
assign1.Assign("Classification", "SCALARS", "POINT_DATA")
map1 = vtk.vtkImageSliceMapper()
map1.BorderOn()
map1.SliceAtFocalPointOn()
map1.SliceFacesCameraOn()
map1.SetInputConnection(assign1.GetOutputPort())
map1.Update()
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')
