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 __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 __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 InitializeClassActivationMap(self):
self.cam_data = vtk.vtkImageData()
self.cam_data.SetOrigin([0, 0, 0])
self.cam_data.SetDimensions(
64,
64,
64,
)
self.cam_data.AllocateScalars(vtk.VTK_UNSIGNED_INT, 1)
self.cam_data.SetSpacing([1.0, 1.0, 1.0])
#set Class Activation Map
cam_color_function = vtk.vtkColorTransferFunction()
cam_opacity_function = vtk.vtkPiecewiseFunction()
scalarRange = [0.0, 255.0]
cam_volume_property = vtk.vtkVolumeProperty()
cam_color_function.AddRGBPoint((scalarRange[0] + scalarRange[1]) * 0.4,
0.0, 0.0, 1.0)
cam_color_function.AddRGBPoint((scalarRange[0] + scalarRange[1]) * 0.7,
0.0, 1.0, 0.0)
cam_color_function.AddRGBPoint(scalarRange[1], 1.0, 0.0, 0.0)
cam_opacity_function.AddPoint((scalarRange[0] + scalarRange[1]) * 0.0,
0.3)
cam_opacity_function.AddPoint(scalarRange[1], 0.3)
cam_volume_property.SetColor(cam_color_function)
cam_volume_property.SetScalarOpacity(cam_opacity_function)
cam_volume_property.ShadeOff()
cam_volume_property.SetInterpolationTypeToLinear()
self.m_colorMapMapper.SetInputData(self.cam_data)
self.m_colorMapMapper.SetBlendModeToMaximumIntensity()
#Actor
self.m_colorMapVolume.SetMapper(self.m_colorMapMapper)
self.m_colorMapVolume.SetProperty(cam_volume_property)
self.m_colorMapVolume.SetPosition([0, 0, 0])
lookupTable = vtk.vtkLookupTable()
lookupTable.SetTableRange(0.0, 255.0)
lookupTable.SetHueRange(0.7, 0.0)
lookupTable.Build()
imageProperty = vtk.vtkImageProperty()
imageProperty.SetInterpolationTypeToLinear()
imageProperty.SetLookupTable(lookupTable)
imageProperty.SetOpacity(0.3)
#Slice
for i in range(3):
self.m_colorMapResliceMapper[i].SetInputData(self.cam_data)
self.m_colorMapResliceMapper[i].SetOrientation(i)
self.m_colorMapResliceActor[i].SetMapper(
self.m_colorMapResliceMapper[i])
self.m_colorMapResliceActor[i].SetProperty(imageProperty)
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 __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 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_slicer(renderer, brain):
x = brain.extent[1]
y = brain.extent[3]
z = brain.extent[5]
axial = vtk.vtkImageActor()
axial_prop = vtk.vtkImageProperty()
axial_prop.SetOpacity(0)
axial.SetProperty(axial_prop)
axial.GetMapper().SetInputConnection(brain.image_mapper.GetOutputPort())
axial.SetDisplayExtent(0, x, 0, y, int(z / 2), int(z / 2))
axial.InterpolateOn()
axial.ForceOpaqueOn()
coronal = vtk.vtkImageActor()
cor_prop = vtk.vtkImageProperty()
cor_prop.SetOpacity(0)
coronal.SetProperty(cor_prop)
coronal.GetMapper().SetInputConnection(brain.image_mapper.GetOutputPort())
coronal.SetDisplayExtent(0, x, int(y / 2), int(y / 2), 0, z)
coronal.InterpolateOn()
coronal.ForceOpaqueOn()
sagittal = vtk.vtkImageActor()
sag_prop = vtk.vtkImageProperty()
sag_prop.SetOpacity(0)
sagittal.SetProperty(sag_prop)
sagittal.GetMapper().SetInputConnection(brain.image_mapper.GetOutputPort())
sagittal.SetDisplayExtent(int(x / 2), int(x / 2), 0, y, 0, z)
sagittal.InterpolateOn()
sagittal.ForceOpaqueOn()
renderer.AddActor(axial)
renderer.AddActor(coronal)
renderer.AddActor(sagittal)
return [axial, coronal, sagittal]
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 __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 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 update_property(self):
prop = vtk.vtkImageProperty()
if self._clim is not None:
clim = self._clim
window = max(clim) - min(clim)
level = window / 2. + min(clim)
prop.SetColorWindow(window)
prop.SetColorLevel(level)
prop.SetAmbient(self._ambient)
prop.SetDiffuse(self._diffuse)
prop.SetOpacity(self._alpha)
if self._interp:
prop.SetInterpolationTypeToLinear()
else:
prop.SetInterpolationTypeToNearest()
self._property = prop
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()
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
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
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)
input1Slice = vtk.vtkImageSlice()
input1Slice.SetMapper(input1Mapper)
input1Slice.SetProperty(image1Property)
# Setup input2 Mapper + Property -> Slice
input2Mapper = vtk.vtkImageResliceMapper()
input2Mapper.SetInputConnection(reader2.GetOutputPort())
input2Mapper.SliceAtFocalPointOn()
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() 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)
color_func = vtk.vtkColorTransferFunction()
opac_func = vtk.vtkPiecewiseFunction()
volume_prop = vtk.vtkVolumeProperty()
volume_mapper = vtk.vtkSmartVolumeMapper()
volume_actor = vtk.vtkVolume()
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 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()
print("Reading {}".format(args.inputImage))
inputReader.Update()
gridReader = vtk.vtkNIFTIImageReader()
gridReader.SetFileName(args.inputGrid)
print("Reading {}".format(args.inputGrid))
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
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 SliceViewer(input_filename, window, level, nThreads):
# Python 2/3 compatible input
from six.moves import input
# Read input
if not os.path.isfile(input_filename):
os.sys.exit('[ERROR] Cannot find file \"{}\"'.format(input_filename))
# Set a minimum thread count
nThreads = max(1, nThreads)
# Read the input
reader = get_vtk_reader(input_filename)
if reader is None:
os.sys.exit('[ERROR] Cannot find reader for file \"{}\"'.format(input_filename))
print('Reading input image ' + input_filename)
reader.SetFileName(input_filename)
reader.Update()
# Get scalar range for W/L and padding
scalarRanges = reader.GetOutput().GetScalarRange()
# Determine if we need to autocompute the window/level
if window <= 0:
window = scalarRanges[1] - scalarRanges[0]
level = (scalarRanges[1] + scalarRanges[0])/2
# Setup input Mapper + Property -> Slice
inputMapper = vtk.vtkOpenGLImageSliceMapper()
inputMapper.SetInputConnection(reader.GetOutputPort())
inputMapper.SliceAtFocalPointOn()
inputMapper.SliceFacesCameraOn()
inputMapper.BorderOn()
inputMapper.SetNumberOfThreads(nThreads)
inputMapper.StreamingOn()
imageProperty = vtk.vtkImageProperty()
imageProperty.SetColorLevel(level)
imageProperty.SetColorWindow(window)
imageProperty.SetInterpolationTypeToNearest()
inputSlice = vtk.vtkImageSlice()
inputSlice.SetMapper(inputMapper)
inputSlice.SetProperty(imageProperty)
# Create Renderer -> RenderWindow -> RenderWindowInteractor -> InteractorStyle
renderer = vtk.vtkRenderer()
renderer.AddActor(inputSlice)
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("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 = scalarRanges[1] - scalarRanges[0]
level = (scalarRanges[1] + scalarRanges[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()
# 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) ia.SetProperty(ip) ren1.AddViewProp(ia) ren1.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(300, 300)
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()
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()
