def _setup_slices(self):
"""Create the slices. No actor required in this case"""
picker = vtk.vtkCellPicker()
picker_tolerance = 0.005
picker.SetTolerance(picker_tolerance)
text_color = (0., 0., 0.)
self._planes.append(vtk.vtkImagePlaneWidget())
self._planes[0].SetInputData(self._volume)
self._planes[0].UserControlledLookupTableOn()
self._planes[0].SetLookupTable(self._lut)
self._planes[0].SetPlaneOrientationToXAxes()
self._planes[0].SetSliceIndex(self._volume.GetExtent()[1]/2) # GetExtent returns a six length array, begin-end pairs
self._planes[0].DisplayTextOn()
self._planes[0].GetTextProperty().SetColor(text_color)
self._planes[0].SetPicker(picker)
self._planes[0].SetLeftButtonAction(1)
self._planes[0].SetMiddleButtonAction(2)
self._planes[0].SetRightButtonAction(0)
self._planes[0].SetInteractor(self._vtk_widget)
# self._planes[0].On()
self._planes.append(vtk.vtkImagePlaneWidget())
self._planes[1].SetInputData(self._volume)
self._planes[1].UserControlledLookupTableOn()
self._planes[1].SetLookupTable(self._lut)
self._planes[1].SetPlaneOrientationToZAxes()
self._planes[1].SetSliceIndex(self._volume.GetExtent()[5]/2) # GetExtent returns a six length array, begin-end pairs
self._planes[1].DisplayTextOn()
self._planes[1].GetTextProperty().SetColor(text_color)
self._planes[1].SetPicker(picker)
self._planes[1].SetLeftButtonAction(1)
self._planes[1].SetMiddleButtonAction(2)
self._planes[1].SetRightButtonAction(0)
self._planes[1].SetInteractor(self._vtk_widget)
def __init__(self, imageData=None):
MarkerWindowInteractor.__init__(self) #does this really just control the markers or is it for the other frames too?
print "PlaneWidgetsXYZ.__init__()"
self.vtksurface = None
self.interactButtons = (1,2,3)
self.sharedPicker = vtk.vtkCellPicker()
#self.sharedPicker.SetTolerance(0.005)
self.SetPicker(self.sharedPicker)
#initialize all three axes slice objects on the bottom of the window
self.pwX = vtk.vtkImagePlaneWidget()
self.pwY = vtk.vtkImagePlaneWidget()
self.pwZ = vtk.vtkImagePlaneWidget()
self.textActors = {}
self.boxes = {}
self.set_image_data(imageData)
self.Render()
self.vtk_translation = zeros(3, 'd')
self.vtk_rotation = zeros(3, 'd')
def __init__(self, imageData=None):
MarkerWindowInteractor.__init__(self)
print "PlaneWidgetsXYZ.__init__()"
self.vtksurface = None
self.interactButtons = (1,2,3)
self.sharedPicker = vtk.vtkCellPicker()
#self.sharedPicker.SetTolerance(0.005)
self.SetPicker(self.sharedPicker)
self.pwX = vtk.vtkImagePlaneWidget()
self.pwY = vtk.vtkImagePlaneWidget()
self.pwZ = vtk.vtkImagePlaneWidget()
self.textActors = {}
self.boxes = {}
self.set_image_data(imageData)
self.Render()
self.vtk_translation = zeros(3, 'd')
self.vtk_rotation = zeros(3, 'd')
def Execute(self):
if self.Image == None:
self.PrintError('Error: no Image.')
self.CroppedImage.DeepCopy(self.Image)
if self.Interactive == 1:
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.PlaneWidgetX = vtk.vtkImagePlaneWidget()
self.PlaneWidgetX.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetY = vtk.vtkImagePlaneWidget()
self.PlaneWidgetY.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetZ = vtk.vtkImagePlaneWidget()
self.PlaneWidgetZ.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.BoxWidget = vtk.vtkBoxWidget()
self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.Display()
while (self.BoxActive == 1):
self.ExtractVOI()
self.Image = self.CroppedImage
self.Display()
else:
self.ExtractVOI()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
self.Image = self.CroppedImage
def __init__(self, imageData=None):
MarkerWindowInteractor.__init__(self)
ThreeDimRenderWindow.__init__(self)
if shared.debug: print "PlaneWidgetsXYZ.__init__()"
self.vtksurface = None
self.interactButtons = (1,2,3)
self.sharedPicker = vtk.vtkCellPicker()
#self.sharedPicker.SetTolerance(0.005)
self.SetPicker(self.sharedPicker)
self.pwX = vtk.vtkImagePlaneWidget()
self.pwY = vtk.vtkImagePlaneWidget()
self.pwZ = vtk.vtkImagePlaneWidget()
self.axes_labels = []
self.set_image_data(imageData)
self.Render()
self.vtk_translation = np.zeros(3, 'd')
self.vtk_rotation = np.zeros(3, 'd')
def Execute(self):
if self.Image == None:
self.PrintError('Error: no Image.')
if self.Interactive == 1:
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
self.PlaneWidgetX = vtk.vtkImagePlaneWidget()
self.PlaneWidgetX.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetY = vtk.vtkImagePlaneWidget()
self.PlaneWidgetY.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetZ = vtk.vtkImagePlaneWidget()
self.PlaneWidgetZ.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.BoxWidget = vtk.vtkBoxWidget()
self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.vmtkRenderer.AddKeyBinding('i','Interact.', self.InteractCallback)
self.Display()
while (self.BoxActive == 1):
self.PaintVOI()
self.Display()
else:
self.PaintVOI()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def __init__(self, rwi, renderer):
# nnsmit-edit
self.overlay_active = 0;
# end edit
self.rwi = rwi
self.renderer = renderer
istyle = vtk.vtkInteractorStyleTrackballCamera()
rwi.SetInteractorStyle(istyle)
# we unbind the existing mousewheel handler so it doesn't
# interfere
rwi.Unbind(wx.EVT_MOUSEWHEEL)
rwi.Bind(wx.EVT_MOUSEWHEEL, self._handler_mousewheel)
self.ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.ipws[0].GetLookupTable()
for ipw in self.ipws:
ipw.SetInteractor(rwi)
ipw.SetLookupTable(lut)
# nnsmit-edit
self.overlay_ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut2 = self.overlay_ipws[0].GetLookupTable()
lut2.SetNumberOfTableValues(3)
lut2.SetTableValue(0,0,0,0,0)
lut2.SetTableValue(1,0.5,0,1,1)
lut2.SetTableValue(2,1,0,0,1)
lut2.Build()
for ipw_overlay in self.overlay_ipws:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut2)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# now actually connect the sync_overlay observer
for i,ipw in enumerate(self.ipws):
ipw.AddObserver('InteractionEvent',lambda vtk_o, vtk_e, i=i: self.observer_sync_overlay(self.ipws,i))
# end edit
# we only set the picker on the visible IPW, else the
# invisible IPWs block picking!
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.ipws[0].SetPicker(self.picker)
self.outline_source = vtk.vtkOutlineCornerFilter()
m = vtk.vtkPolyDataMapper()
m.SetInput(self.outline_source.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
a.PickableOff()
self.outline_actor = a
self.dv_orientation_widget = DVOrientationWidget(rwi)
# this can be used by clients to store the current world
# position
self.current_world_pos = (0,0,0)
self.current_index_pos = (0,0,0)
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
VisualizationModule.__init__(self, parent, visualizer, **kws)
self.on = 0
self.renew = 1
self.mapper = vtk.vtkPolyDataMapper()
self.eventDesc = "Rendering orthogonal slices"
self.outline = vtk.vtkOutlineFilter()
self.outlineMapper = vtk.vtkPolyDataMapper()
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(self.outlineMapper)
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetX.DisplayTextOn()
self.planeWidgetX.SetPicker(self.picker)
self.planeWidgetX.SetKeyPressActivationValue("x")
#self.planeWidgetX.UserControlledLookupTableOn()
self.prop1 = self.planeWidgetX.GetPlaneProperty()
#self.prop1.SetColor(1, 0, 0)
self.planeWidgetX.SetResliceInterpolateToCubic()
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetY.SetPicker(self.picker)
self.planeWidgetY.SetKeyPressActivationValue("y")
self.prop2 = self.planeWidgetY.GetPlaneProperty()
self.planeWidgetY.SetResliceInterpolateToCubic()
#self.planeWidgetY.UserControlledLookupTableOn()
#self.prop2.SetColor(1, 1, 0)
# for the z-slice, turn off texture interpolation:
# interpolation is now nearest neighbour, to demonstrate
# cross-hair cursor snapping to pixel centers
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.planeWidgetZ.DisplayTextOn()
self.planeWidgetZ.SetPicker(self.picker)
self.planeWidgetZ.SetKeyPressActivationValue("z")
self.prop3 = self.planeWidgetZ.GetPlaneProperty()
#self.prop3.SetColor(1, 0, 1)
#self.planeWidgetZ.UserControlledLookupTableOn()
self.planeWidgetZ.SetResliceInterpolateToCubic()
self.renderer = self.parent.getRenderer()
self.renderer.AddActor(self.outlineActor)
self.useOutline = 1
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
self.planeWidgetX.SetInteractor(iactor)
self.planeWidgetY.SetInteractor(iactor)
self.planeWidgetZ.SetInteractor(iactor)
lib.messenger.connect(None, "zslice_changed", self.setZ)
self.filterDesc = "View orthogonal slices"
def __init__(self):
""" initialize visualization with standard vtk actors, renders, windowsn, interactors """
# use cell picker for interacting with the image orthogonal views.
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
# Create 3 orthogonal view using the ImagePlaneWidget
self.xImagePlaneWidget = vtk.vtkImagePlaneWidget()
self.yImagePlaneWidget = vtk.vtkImagePlaneWidget()
self.zImagePlaneWidget = vtk.vtkImagePlaneWidget()
# The 3 image plane widgets
self.xImagePlaneWidget.DisplayTextOn();
self.xImagePlaneWidget.SetPicker(self.picker);
self.xImagePlaneWidget.RestrictPlaneToVolumeOn();
self.xImagePlaneWidget.SetKeyPressActivationValue('x');
self.xImagePlaneWidget.GetPlaneProperty().SetColor(1, 0, 0);
self.xImagePlaneWidget.SetResliceInterpolateToNearestNeighbour();
self.yImagePlaneWidget.DisplayTextOn();
self.yImagePlaneWidget.SetPicker(self.picker);
self.yImagePlaneWidget.RestrictPlaneToVolumeOn();
self.yImagePlaneWidget.SetKeyPressActivationValue('y');
self.yImagePlaneWidget.GetPlaneProperty().SetColor(0, 1, 0);
self.yImagePlaneWidget.SetLookupTable(self.xImagePlaneWidget.GetLookupTable());
self.zImagePlaneWidget.DisplayTextOn();
self.zImagePlaneWidget.SetPicker(self.picker);
self.zImagePlaneWidget.SetKeyPressActivationValue('z');
self.zImagePlaneWidget.GetPlaneProperty().SetColor(0, 0, 1);
self.zImagePlaneWidget.SetLookupTable(self.xImagePlaneWidget.GetLookupTable());
self.zImagePlaneWidget.SetRightButtonAutoModifier(1);
# Create a renderer, render window, and render window interactor to
# display the results.
self.renderer1 = vtk.vtkRenderer()
self.renWin1 = vtk.vtkRenderWindow()
self.iren1 = vtk.vtkRenderWindowInteractor()
self.renWin1.SetSize(1000, 800);
self.renWin1.AddRenderer(self.renderer1)
self.iren1.SetRenderWindow(self.renWin1)
self.xImagePlaneWidget.SetInteractor( self.iren1 )
self.yImagePlaneWidget.SetInteractor( self.iren1 )
self.zImagePlaneWidget.SetInteractor( self.iren1 )
# Set Up Camera view
self.camera = self.renderer1.GetActiveCamera()
self.renderer1.SetBackground(0.0, 0.0, 0.0)
self.iren1.SetPicker(self.picker)
self.T1origin = [0,0,0]
self.T2origin = [0,0,0]
self.T2extent = [0,0,0,0,0,0]
self.T1extent = [0,0,0,0,0,0]
self.T1spacing = [0,0,0]
def __init__(self, interactor, renderer):
self.interactor = interactor
self.renderer = renderer
self.pwX = vtk.vtkImagePlaneWidget()
self.pwY = vtk.vtkImagePlaneWidget()
self.pwZ = vtk.vtkImagePlaneWidget()
self._usingPlanes = False
self.readerDlg = image_reader.widgets['dlgReader']
self.propsDlg = self.make_prop_dialog()
def ImagePlaneDemo(img):
# create a window
window = vtk.vtkRenderWindow()
# create interactor
interactor = vtk.vtkRenderWindowInteractor()
window.SetInteractor(interactor)
# create 4 renderers
xmins = [0,.5,0,.5]
xmaxs = [0.5,1,0.5,1]
ymins = [0,0,0.5,0.5]
ymaxs = [0.5,0.5,1,1]
render_list = []
for i in range(4):
renderer = vtk.vtkRenderer()
render_list.append(renderer)
window.AddRenderer(renderer)
renderer.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i])
# create plane source here
plane_X = vtk.vtkImagePlaneWidget()
plane_Y = vtk.vtkImagePlaneWidget()
plane_Z = vtk.vtkImagePlaneWidget()
plane_X.SetInteractor(interactor)
plane_Y.SetInteractor(interactor)
plane_Z.SetInteractor(interactor)
plane_X.SetDefaultRenderer(render_list[0])
plane_Y.SetDefaultRenderer(render_list[1])
plane_Z.SetDefaultRenderer(render_list[2])
plane_X.SetCurrentRenderer(render_list[3])
plane_Y.SetCurrentRenderer(render_list[3])
plane_Z.SetCurrentRenderer(render_list[3])
plane_X.SetInputData(img)
plane_Y.SetInputData(img)
plane_Z.SetInputData(img)
plane_X.SetPlaneOrientationToXAxes()
plane_Y.SetPlaneOrientationToYAxes()
plane_Z.SetPlaneOrientationToZAxes()
plane_X.On()
plane_Y.On()
plane_Z.On()
window.Render()
interactor.Start()
def _createIPWs(self):
self._ipw1 = vtk.vtkImagePlaneWidget()
self._ipw2 = vtk.vtkImagePlaneWidget()
for ipw, vtkImporter in ((self._ipw1, self._vtkImporter1),
(self._ipw2, self._vtkImporter2)):
vtkImporter.Update()
ipw.SetInput(vtkImporter.GetOutput())
ipw.SetPlaneOrientation(2)
ipw.SetInteractor(self.viewerFrame.threedRWI)
ipw.On()
ipw.InteractionOff()
self._setModeRedGreen()
def add_overlay(self, id, rgba_colour):
"""Creates and ads a new (set of) image plane widgets corresponding to a new overlay.
id : the string id which will be used to identify this overlay for future lookups.
rgba_colour : a length 4 vector giving the red,green,blue,opacity value for this overlay. Range = [0,1]
"""
if self.ipw_triads.has_key(id):
raise ValueError('The overlay id = "%s" is already in use! Cannot this id - aborting.' % id)
else:
new_ipw_triad = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = new_ipw_triad[0].GetLookupTable()
lut.SetNumberOfTableValues(2)
if len(self.ipw_triads) == 0:
lut.SetTableValue(0,0,0,0,0.1) #Almost-transparent black - for showing the pickable plane
else:
lut.SetTableValue(0,0,0,0,0) #Transparent: for non-interfering overlay on existing layers
lut.SetTableValue(1,rgba_colour[0],rgba_colour[1],rgba_colour[2],rgba_colour[3]) #Specified RGBA for binary "true"
lut.Build()
for ipw in new_ipw_triad:
ipw.SetInteractor(self.rwi)
ipw.SetLookupTable(lut)
self.ipw_triads[id] = new_ipw_triad
base_ipw_triad = self.ipw_triads[0]
# now actually connect the sync_overlay observer
for i,ipw in enumerate(base_ipw_triad):
ipw.AddObserver('InteractionEvent',lambda vtk_o, vtk_e, i=i: self.observer_sync_overlay(base_ipw_triad, new_ipw_triad, i))
def DisplayComponent(source):
renderer = vtk.vtkRenderer()
win = vtk.vtkRenderWindow()
win.AddRenderer(renderer)
style = vtk.vtkInteractorStyleImage()
intact = vtk.vtkRenderWindowInteractor()
intact.SetInteractorStyle(style)
intact.SetRenderWindow(win)
planeX = vtk.vtkImagePlaneWidget()
planeY = vtk.vtkImagePlaneWidget()
planeZ = vtk.vtkImagePlaneWidget()
planeX.SetInteractor(intact)
planeY.SetInteractor(intact)
planeZ.SetInteractor(intact)
planeX.SetInputData(source)
planeY.SetInputData(source)
planeZ.SetInputData(source)
planeX.SetPlaneOrientationToXAxes()
planeY.SetPlaneOrientationToYAxes()
planeZ.SetPlaneOrientationToZAxes()
planeX.On()
planeY.On()
planeZ.On()
global pos
pos = 1
def myCallback(obj,event):
global pos
#print obj.__class__.__name__," called"
key = obj.GetKeySym()
if key=="Up":
pos = pos+1
planeX.SetSliceIndex(pos)
print pos
win.Render()
else:
pass
intact.AddObserver(vtk.vtkCommand.KeyPressEvent,myCallback)
intact.Start()
def Execute(self):
if (self.Image == None) & (self.Display == 1):
self.PrintError('Error: no Image.')
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.PaintedImage = vtk.vtkImageData()
self.PaintedImage.DeepCopy(self.Image)
self.vmtkRenderer.RegisterScript(self)
##self.PrintLog('Ctrl + left click to add seed.')
self.Picker = vtk.vtkCellPicker()
self.Picker.SetTolerance(0.005)
self.PlaneWidgetX = vtk.vtkImagePlaneWidget()
self.PlaneWidgetX.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetX.AddObserver("StartInteractionEvent", self.StartInteraction)
self.PlaneWidgetX.AddObserver("InteractionEvent", self.Interaction)
self.PlaneWidgetX.AddObserver("EndInteractionEvent", self.EndInteraction)
self.PlaneWidgetX.SetPicker(self.Picker)
self.PlaneWidgetY = vtk.vtkImagePlaneWidget()
self.PlaneWidgetY.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetY.AddObserver("StartInteractionEvent", self.StartInteraction)
self.PlaneWidgetY.AddObserver("InteractionEvent", self.Interaction)
self.PlaneWidgetY.AddObserver("EndInteractionEvent", self.EndInteraction)
self.PlaneWidgetY.SetPicker(self.Picker)
self.PlaneWidgetZ = vtk.vtkImagePlaneWidget()
self.PlaneWidgetZ.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
self.PlaneWidgetZ.AddObserver("StartInteractionEvent", self.StartInteraction)
self.PlaneWidgetZ.AddObserver("InteractionEvent", self.Interaction)
self.PlaneWidgetZ.AddObserver("EndInteractionEvent", self.EndInteraction)
self.PlaneWidgetZ.SetPicker(self.Picker)
self.BuildView()
self.WidgetsOff()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
def widget(self):
img = vtk.vtkImagePlaneWidget()
img.SetInputData(self.rdr.GetOutput())
img.SetInteractor(self.interactor)
img_data = self.rdr.GetOutput()
dimensions = img_data.GetDimensions()
mid_point=int(dimensions[1]/2)
img.SetSliceIndex(mid_point)
img.On()
self.img = img
def __init__(self): super(ClippingBox, self).__init__() self.widget = None self.clippingBox = vtkBoxWidget() self.planes = [vtkImagePlaneWidget() for _ in range(6)] self.transform = vtkTransform() # For future functionality self._clippingBoxState = False self._clippingPlanesState = False
def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def SetInput(self, imagedata):
axes = PLANE_DATA[self.orientation][0] # "x", "y" or "z"
colour = PLANE_DATA[self.orientation][1]
#if self.orientation == SAGITAL:
# spacing = min(imagedata.GetSpacing())
# permute = vtk.vtkImagePermute()
# permute.SetInput(imagedata)
# permute.GetOutput().ReleaseDataFlagOn()
# permute.SetOutputSpacing(spacing, spacing, spacing)
# imagedata = permute.GetOutput()
# Picker for enabling plane motion.
# Allows selection of a cell by shooting a ray into graphics window
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
picker.PickFromListOn()
# 3D widget for reslicing image data.
# This 3D widget defines a plane that can be interactively placed in an image volume.
widget = vtk.vtkImagePlaneWidget()
widget.SetInput(imagedata)
widget.SetSliceIndex(self.index)
widget.SetPicker(picker)
widget.SetKeyPressActivationValue(axes)
widget.SetInteractor(self.iren)
widget.TextureVisibilityOff()
widget.DisplayTextOff()
widget.RestrictPlaneToVolumeOff()
exec("widget.SetPlaneOrientationTo"+axes.upper()+"Axes()")
widget.AddObserver("InteractionEvent",self.Update)
self.widget = widget
prop = widget.GetPlaneProperty()
prop.SetColor(colour)
# Syncronize coloured outline with texture appropriately
source = vtk.vtkPlaneSource()
source.SetOrigin(widget.GetOrigin())
source.SetPoint1(widget.GetPoint1())
source.SetPoint2(widget.GetPoint2())
source.SetNormal(widget.GetNormal())
self.source = source
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(source.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(widget.GetTexture())
actor.VisibilityOff()
self.actor = actor
self.render.AddActor(actor)
def __init__(self, vtk_image_data, name = "VtkVolumeModel"):
if not isinstance(vtk_image_data, vtk.vtkImageData):
raise TypeError("input has to be vtkImageData")
VtkModel.__init__(self, name)
self.__vtk_image_data = vtk_image_data
# The slicer for the volume data
self.__image_slicer = vtk.vtkImagePlaneWidget()
self.__image_slicer.SetResliceInterpolateToCubic()
self.__image_slicer.SetInputData(vtk_image_data)
self.__image_slicer.SetPlaneOrientationToZAxes()
def _setup_plane(self):
plane = vtk.vtkImagePlaneWidget()
if vtk_tools.VTK_VERSION >= 6:
plane.SetInputData(self._image_data)
else:
plane.SetInput(self._image_data)
plane.UserControlledLookupTableOn()
plane.SetLookupTable(self._lut)
plane.DisplayTextOn()
plane.SetPicker(self._picker)
plane.SetLeftButtonAction(1)
plane.SetMiddleButtonAction(2)
plane.SetRightButtonAction(0)
plane.SetInteractor(self._vtk_widget)
return plane
def get_plane_widget(input_data, axis=0, slice_idx=10, color=[1, 0, 0], key_value='i'):
plane_widget = vtk.vtkImagePlaneWidget()
plane_widget.DisplayTextOn()
plane_widget.SetInputData(input_data)
plane_widget.SetPlaneOrientation(axis)
plane_widget.SetSliceIndex(slice_idx)
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
plane_widget.SetPicker(picker)
plane_widget.SetKeyPressActivationValue(key_value)
plane_widget.GetPlaneProperty().SetColor(color)
return plane_widget
def setImageData(self, imageData): self.imagedata = imageData scalarRange = self.imagedata.GetScalarRange() self.transfer = vtkColorTransferFunction() self.transfer.SetRange(scalarRange[0], scalarRange[1]) self.transfer.AddRGBPoint(scalarRange[0], 0, 0, 0) self.transfer.AddRGBPoint(scalarRange[1], self.color[0], self.color[1], self.color[2]) self.transfer.Build() # Add a slicer widget that looks at camera self.slicer = vtkImagePlaneWidget() self.slicer.DisplayTextOn() self.slicer.SetInteractor(self.rwi) self.slicer.SetInputData(imageData) self.slicer.SetPlaneOrientation(2) self.slicer.SetRestrictPlaneToVolume(1) self.slicer.PlaceWidget() self.slicer.On() cursorProperty = self.slicer.GetCursorProperty() cursorProperty.SetOpacity(0.0) planeProperty = self.slicer.GetPlaneProperty() planeProperty.SetColor(0, 0, 0) selectedPlaneProperty = self.slicer.GetSelectedPlaneProperty() selectedPlaneProperty.SetColor(0, 0, 0) # Reset the camera and set the clipping range self.renderer.ResetCamera() camera = self.renderer.GetActiveCamera() camera.SetClippingRange(0.1, 10000) if not self.locator: bounds = self.imagedata.GetBounds() size = [bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]] meanSize = sum(size) / len(size) width = meanSize / 20.0 square = CreateSquare(width, self.color) square.GetProperty().SetLineWidth(2) line1 = CreateLine([0, width / 2.0, 0], [0, 10000, 0], self.color) line2 = CreateLine([0, -width / 2.0, 0], [0, -10000, 0], self.color) line3 = CreateLine([width / 2.0, 0, 0], [10000, 0, 0], self.color) line4 = CreateLine([-width / 2.0, 0, 0], [-10000, 0, 0], self.color) self.locator = [square, line1, line2, line3, line4] for actor in self.locator: self.rendererOverlay.AddViewProp(actor)
def setup_plane():
"""Create and setup a singel plane."""
plane = _vtk.vtkImagePlaneWidget()
if VTK_VERSION >= 6:
plane.SetInputData(image_data)
else:
plane.SetInput(image_data)
plane.UserControlledLookupTableOn()
plane.SetLookupTable(lut)
plane.DisplayTextOn()
plane.SetPicker(picker)
plane.SetLeftButtonAction(1)
plane.SetMiddleButtonAction(2)
plane.SetRightButtonAction(0)
plane.SetInteractor(interactor)
return plane
def __init__(self, planeWidget, owner, orientation, imageData=None):
print "PlaneWidgetObserver.__init__(): orientation=",orientation
MarkerWindowInteractor.__init__(self)
self.interactButtons = (1,2,3)
self.pw = planeWidget
self.owner = owner
self.orientation = orientation
self.observer = vtk.vtkImagePlaneWidget()
self.camera = self.renderer.GetActiveCamera()
self.ringActors = vtk.vtkActorCollection()
self.defaultRingLine = 1
self.textActors = {}
self.hasData = 0
self.set_image_data(imageData)
self.lastTime = 0
self.set_mouse1_to_move()
def __init__(self, data_container, parent_qt_frame, busyness_indicator = None):
modelview.Observer.__init__(self)
self.data_container = data_container
# Make sure that the data container has the right type
if not isinstance(self.data_container, dc.DataContainer):
raise TypeError("the data container has the wrong type")
# Register itself as an observer to the data_container
self.data_container.add_observer(self)
self.busyness_indicator = busyness_indicator
# Make sure 'busyness_indicator' has the right type
if self.busyness_indicator and not isinstance(self.busyness_indicator, gui.busy.BusynessIndicator):
print("Warning: input parameter 'busyness_indicator' has the wrong type")
self.busyness_indicator = None
# The render window interactor
self.__vtk_widget = QVTKWidget(parent_qt_frame)
self.__vtk_widget.Renderer.SetBackground(0.4, 0.41, 0.42)
# This guy is very important: it handles all the model selection in the 3D view
self.__model_picker = ModelPicker(self.data_container, self.interactor)
# We want to see xyz axes in the lower left corner of the window
lower_left_axes_actor = vtk.vtkAxesActor()
lower_left_axes_actor.SetXAxisLabelText("X")
lower_left_axes_actor.SetYAxisLabelText("Y")
lower_left_axes_actor.SetZAxisLabelText("Z")
lower_left_axes_actor.SetTotalLength(1.5, 1.5, 1.5)
self.lower_left_axes_widget = vtk.vtkOrientationMarkerWidget()
self.lower_left_axes_widget.SetOrientationMarker(lower_left_axes_actor)
self.lower_left_axes_widget.KeyPressActivationOff()
self.lower_left_axes_widget.SetInteractor(self.interactor)
self.lower_left_axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)
self.lower_left_axes_widget.SetEnabled(1)
self.lower_left_axes_widget.InteractiveOff()
# The slicer for the volume data
self.volume_widget = vtk.vtkImagePlaneWidget()
self.volume_widget.SetInteractor(self.interactor)
self.volume_widget.SetResliceInterpolateToCubic()
def get_plane(self, axis=0, slice_idx=10, color=[1, 0, 0], key='i'):
"""
ONE plane widget
"""
plane = vtk.vtkImagePlaneWidget()
plane.DisplayTextOn()
plane.SetInputData(self.reader)
plane.SetPlaneOrientation(axis)
plane.SetSliceIndex(slice_idx)
# 0: neares, 1: liner, 2: cubic
plane.SetResliceInterpolate(2)
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
plane.SetPicker(picker)
plane.SetKeyPressActivationValue(key)
plane.GetPlaneProperty().SetColor(color)
return plane
def Create(self):
self.plane_widget = plane_widget = vtk.vtkImagePlaneWidget()
plane_widget.SetInputData(self.img)
plane_widget.SetPlaneOrientationToXAxes()
#plane_widget.SetResliceInterpolateToLinear()
plane_widget.TextureVisibilityOff()
#Set left mouse button to move and rotate plane
plane_widget.SetLeftButtonAction(1)
#SetColor margin to green
margin_property = plane_widget.GetMarginProperty()
margin_property.SetColor(0, 0.8, 0)
#Disable cross
cursor_property = plane_widget.GetCursorProperty()
cursor_property.SetOpacity(0)
self.plane_source = plane_source = vtk.vtkPlaneSource()
plane_source.SetOrigin(plane_widget.GetOrigin())
plane_source.SetPoint1(plane_widget.GetPoint1())
plane_source.SetPoint2(plane_widget.GetPoint2())
plane_source.SetNormal(plane_widget.GetNormal())
plane_mapper = self.plane_mapper = vtk.vtkPolyDataMapper()
plane_mapper.SetInputData(plane_source.GetOutput())
self.plane_actor = plane_actor = vtk.vtkActor()
plane_actor.SetMapper(plane_mapper)
plane_actor.GetProperty().BackfaceCullingOn()
plane_actor.GetProperty().SetOpacity(0)
plane_widget.AddObserver("InteractionEvent", self.Update)
Publisher.sendMessage('AppendActor', actor=self.plane_actor)
Publisher.sendMessage('Set Widget Interactor',
widget=self.plane_widget)
plane_actor.SetVisibility(1)
plane_widget.On()
self.plane = plane = vtk.vtkPlane()
plane.SetNormal(self.plane_source.GetNormal())
plane.SetOrigin(self.plane_source.GetOrigin())
self.volume_mapper.AddClippingPlane(plane)
#Storage First Position
self.origin = plane_widget.GetOrigin()
self.p1 = plane_widget.GetPoint1()
self.p2 = plane_widget.GetPoint2()
self.normal = plane_widget.GetNormal()
def __init__(self, data_dir, reader):
table = vtk.vtkLookupTable()
table.SetRange(2440, 2800) # image intensity range
table.SetValueRange(0.0, 1) # from black to white
#table.SetAlphaRange(1.0 ,1.0)
table.SetHueRange(0.0, 0.1)
table.SetSaturationRange(0.0, 0.2) # no color saturation
table.SetRampToLinear()
table.Build()
planeWidget = vtk.vtkImagePlaneWidget()
planeWidget.SetInputConnection(reader.GetOutputPort())
planeWidget.RestrictPlaneToVolumeOn()
planeWidget.SetResliceInterpolateToLinear()
planeWidget.SetPlaneOrientationToXAxes()
planeWidget.SetLookupTable(table)
planeWidget.PlaceWidget()
#To Update Placement of Plane Widget in MainProgram
self.planeWidget = planeWidget
self.reader = reader
def add_overlay(self, id, rgba_colour):
"""Creates and ads a new (set of) image plane widgets corresponding to a new overlay.
id : the string id which will be used to identify this overlay for future lookups.
rgba_colour : a length 4 vector giving the red,green,blue,opacity value for this overlay. Range = [0,1]
"""
if self.ipw_triads.has_key(id):
raise ValueError(
'The overlay id = "%s" is already in use! Cannot this id - aborting.'
% id)
else:
new_ipw_triad = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = new_ipw_triad[0].GetLookupTable()
lut.SetNumberOfTableValues(2)
if len(self.ipw_triads) == 0:
lut.SetTableValue(
0, 0, 0, 0, 0.1
) #Almost-transparent black - for showing the pickable plane
else:
lut.SetTableValue(
0, 0, 0, 0, 0
) #Transparent: for non-interfering overlay on existing layers
lut.SetTableValue(
1, rgba_colour[0], rgba_colour[1], rgba_colour[2],
rgba_colour[3]) #Specified RGBA for binary "true"
lut.Build()
for ipw in new_ipw_triad:
ipw.SetInteractor(self.rwi)
ipw.SetLookupTable(lut)
self.ipw_triads[id] = new_ipw_triad
base_ipw_triad = self.ipw_triads[0]
# now actually connect the sync_overlay observer
for i, ipw in enumerate(base_ipw_triad):
ipw.AddObserver(
'InteractionEvent',
lambda vtk_o, vtk_e, i=i: self.observer_sync_overlay(
base_ipw_triad, new_ipw_triad, i))
def Create(self):
self.plane_widget = plane_widget = vtk.vtkImagePlaneWidget()
plane_widget.SetInputData(self.img)
plane_widget.SetPlaneOrientationToXAxes()
#plane_widget.SetResliceInterpolateToLinear()
plane_widget.TextureVisibilityOff()
#Set left mouse button to move and rotate plane
plane_widget.SetLeftButtonAction(1)
#SetColor margin to green
margin_property = plane_widget.GetMarginProperty()
margin_property.SetColor(0,0.8,0)
#Disable cross
cursor_property = plane_widget.GetCursorProperty()
cursor_property.SetOpacity(0)
self.plane_source = plane_source = vtk.vtkPlaneSource()
plane_source.SetOrigin(plane_widget.GetOrigin())
plane_source.SetPoint1(plane_widget.GetPoint1())
plane_source.SetPoint2(plane_widget.GetPoint2())
plane_source.SetNormal(plane_widget.GetNormal())
plane_mapper = self.plane_mapper = vtk.vtkPolyDataMapper()
plane_mapper.SetInputData(plane_source.GetOutput())
self.plane_actor = plane_actor = vtk.vtkActor()
plane_actor.SetMapper(plane_mapper)
plane_actor.GetProperty().BackfaceCullingOn()
plane_actor.GetProperty().SetOpacity(0)
plane_widget.AddObserver("InteractionEvent", self.Update)
Publisher.sendMessage('AppendActor', self.plane_actor)
Publisher.sendMessage('Set Widget Interactor', self.plane_widget)
plane_actor.SetVisibility(1)
plane_widget.On()
self.plane = plane = vtk.vtkPlane()
plane.SetNormal(self.plane_source.GetNormal())
plane.SetOrigin(self.plane_source.GetOrigin())
self.volume_mapper.AddClippingPlane(plane)
#Storage First Position
self.origin = plane_widget.GetOrigin()
self.p1 = plane_widget.GetPoint1()
self.p2 = plane_widget.GetPoint2()
self.normal = plane_widget.GetNormal()
def __init__(self, rwi, renderer):
self.rwi = rwi
self.renderer = renderer
istyle = vtk.vtkInteractorStyleTrackballCamera()
rwi.SetInteractorStyle(istyle)
# we unbind the existing mousewheel handler so it doesn't
# interfere
rwi.Unbind(wx.EVT_MOUSEWHEEL)
rwi.Bind(wx.EVT_MOUSEWHEEL, self._handler_mousewheel)
self.ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.ipws[0].GetLookupTable()
for ipw in self.ipws:
ipw.SetInteractor(rwi)
ipw.SetLookupTable(lut)
# we only set the picker on the visible IPW, else the
# invisible IPWs block picking!
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.ipws[0].SetPicker(self.picker)
self.outline_source = vtk.vtkOutlineCornerFilter()
m = vtk.vtkPolyDataMapper()
m.SetInput(self.outline_source.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
a.PickableOff()
self.outline_actor = a
self.dv_orientation_widget = DVOrientationWidget(rwi)
# this can be used by clients to store the current world
# position
self.current_world_pos = (0,0,0)
self.current_index_pos = (0,0,0)
def _activateOverlayIPW(self):
if (
self._overlayipw == None
and self._ipw
and self._histogram.GetInput(0)
and self._histogram.GetInput(1)
and len(self._selectors) > 0
):
# we only do this if absolutely necessary
# connect these two up ONLY if we have valid selectors
self._stencil.SetStencil(self._pdToImageStencil.GetOutput())
self._overlayipw = vtk.vtkImagePlaneWidget()
self._overlayipw.SetInput(self._stencil.GetOutput())
self._stencil.GetOutput().Update()
self._overlayipw.SetInput(self._stencil.GetOutput())
self._overlayipw.SetInteractor(self._viewFrame.rwi)
self._overlayipw.SetPlaneOrientation(2)
self._overlayipw.SetSliceIndex(0)
# build the lut
lut = vtk.vtkLookupTable()
lut.SetTableRange(0, 1)
lut.SetHueRange(0.0, 0.0)
lut.SetSaturationRange(1.0, 1.0)
lut.SetValueRange(1.0, 1.0)
lut.SetAlphaRange(0.0, 0.3)
lut.Build()
self._overlayipw.SetUserControlledLookupTable(1)
self._overlayipw.SetLookupTable(lut)
self._overlayipw.On()
self._overlayipw.InteractionOff()
self._render()
def testBug(self):
# Uncomment the next line if you want to run this via
# `gdb python`.
#raw_input('Hit Ctrl-C')
# Load some data.
v16 = vtk.vtkVolume16Reader()
v16.SetDataDimensions(64, 64)
v16.SetDataByteOrderToLittleEndian()
v16.SetFilePrefix(os.path.join(Testing.VTK_DATA_ROOT,
"Data", "headsq", "quarter"))
v16.SetImageRange(1, 93)
v16.SetDataSpacing(3.2, 3.2, 1.5)
v16.Update()
xMin, xMax, yMin, yMax, zMin, zMax = v16.GetExecutive().GetWholeExtent(v16.GetOutputInformation(0))
img_data = v16.GetOutput()
# **************************************************
# Look here for wierdness.
# Lets create this data using the data from the reader.
my_img_data = vtk.vtkImageData()
my_img_data.SetDimensions(img_data.GetDimensions())
# my_img_data.SetWholeExtent(img_data.GetWholeExtent())
my_img_data.SetExtent(img_data.GetExtent())
# my_img_data.SetUpdateExtent(img_data.GetUpdateExtent())
my_img_data.SetSpacing(img_data.GetSpacing())
my_img_data.SetOrigin(img_data.GetOrigin())
my_img_data.SetScalarType(img_data.GetScalarType(), my_img_data.GetInformation())
my_img_data.GetPointData().SetScalars(img_data.GetPointData().GetScalars())
# hang on to original image data.
orig_img_data = img_data
# hijack img_data with our own. If you comment this out everything is
# fine.
img_data = my_img_data
# **************************************************
spacing = img_data.GetSpacing()
sx, sy, sz = spacing
origin = img_data.GetOrigin()
ox, oy, oz = origin
# An outline is shown for context.
outline = vtk.vtkOutlineFilter()
outline.SetInputData(img_data)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# The shared picker enables us to use 3 planes at one time
# and gets the picking order right
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# The 3 image plane widgets are used to probe the dataset.
planeWidgetX = vtk.vtkImagePlaneWidget()
planeWidgetX.DisplayTextOn()
planeWidgetX.SetInputData(img_data)
planeWidgetX.SetPlaneOrientationToXAxes()
planeWidgetX.SetSliceIndex(32)
planeWidgetX.SetPicker(picker)
planeWidgetX.SetKeyPressActivationValue("x")
prop1 = planeWidgetX.GetPlaneProperty()
prop1.SetColor(1, 0, 0)
planeWidgetY = vtk.vtkImagePlaneWidget()
planeWidgetY.DisplayTextOn()
planeWidgetY.SetInputData(img_data)
planeWidgetY.SetPlaneOrientationToYAxes()
planeWidgetY.SetSliceIndex(32)
planeWidgetY.SetPicker(picker)
planeWidgetY.SetKeyPressActivationValue("y")
prop2 = planeWidgetY.GetPlaneProperty()
prop2.SetColor(1, 1, 0)
planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable())
# for the z-slice, turn off texture interpolation:
# interpolation is now nearest neighbour, to demonstrate
# cross-hair cursor snapping to pixel centers
planeWidgetZ = vtk.vtkImagePlaneWidget()
planeWidgetZ.DisplayTextOn()
planeWidgetZ.SetInputData(img_data)
planeWidgetZ.SetPlaneOrientationToZAxes()
planeWidgetZ.SetSliceIndex(46)
planeWidgetZ.SetPicker(picker)
planeWidgetZ.SetKeyPressActivationValue("z")
prop3 = planeWidgetZ.GetPlaneProperty()
prop3.SetColor(0, 0, 1)
planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable())
# Create the RenderWindow and Renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren)
# Add the outline actor to the renderer, set the background
# color and size
ren.AddActor(outlineActor)
renWin.SetSize(600, 600)
ren.SetBackground(0.1, 0.1, 0.2)
current_widget = planeWidgetZ
mode_widget = planeWidgetZ
# Set the interactor for the widgets
iact = vtk.vtkRenderWindowInteractor()
iact.SetRenderWindow(renWin)
planeWidgetX.SetInteractor(iact)
planeWidgetX.On()
planeWidgetY.SetInteractor(iact)
planeWidgetY.On()
planeWidgetZ.SetInteractor(iact)
planeWidgetZ.On()
# Create an initial interesting view
ren.ResetCamera();
cam1 = ren.GetActiveCamera()
cam1.Elevation(110)
cam1.SetViewUp(0, 0, -1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iact.Initialize()
renWin.Render()
# Compare the images and test.
img_file = "TestImagePlaneWidget.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
# Interact if necessary.
if Testing.isInteractive():
iact.Start()
def raw_image(filepath, renderer):
mask_reader = vtk.vtkNIFTIImageReader()
mask_reader.SetFileName(filepath)
mask_reader.Update()
temp_data = mask_reader.GetOutput()
new_data = vtk.vtkImageData()
new_data.DeepCopy(temp_data)
#outline
outline=vtk.vtkOutlineFilter()
outline.SetInputData(new_data)
outlineMapper=vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
#Picker
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
#PlaneWidget
planeWidgetX = vtk.vtkImagePlaneWidget()
planeWidgetX.DisplayTextOn()
planeWidgetX.SetInputData(new_data)
planeWidgetX.SetPlaneOrientationToXAxes()
planeWidgetX.SetSliceIndex(100)
planeWidgetX.SetPicker(picker)
planeWidgetX.SetKeyPressActivationValue("x")
prop1 = planeWidgetX.GetPlaneProperty()
prop1.SetColor(1, 0, 0)
planeWidgetY = vtk.vtkImagePlaneWidget()
planeWidgetY.DisplayTextOn()
planeWidgetY.SetInputData(new_data)
planeWidgetY.SetPlaneOrientationToYAxes()
planeWidgetY.SetSliceIndex(100)
planeWidgetY.SetPicker(picker)
planeWidgetY.SetKeyPressActivationValue("y")
prop2 = planeWidgetY.GetPlaneProperty()
prop2.SetColor(1, 1, 0)
planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable())
planeWidgetZ = vtk.vtkImagePlaneWidget()
planeWidgetZ.DisplayTextOn()
planeWidgetZ.SetInputData(new_data)
planeWidgetZ.SetPlaneOrientationToZAxes()
planeWidgetZ.SetSliceIndex(100)
planeWidgetZ.SetPicker(picker)
planeWidgetZ.SetKeyPressActivationValue("z")
prop2 = planeWidgetY.GetPlaneProperty()
prop2.SetColor(0, 0, 1)
planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable())
#Add outlineactor
renderer.AddActor(outlineActor)
#Load widget interactors and enable
# planeWidgetX.SetInteractor(interactor)
# planeWidgetX.On()
# planeWidgetY.SetInteractor(interactor)
# planeWidgetY.On()
# planeWidgetZ.SetInteractor(interactor)
# planeWidgetZ.On()
return planeWidgetX, planeWidgetY, planeWidgetZ
def __init__(self, data_dir,reader):
planes = vtk.vtkPlane()
planeC = vtk.vtkPlaneCollection()
planeC.AddItem(planes)
# Stripper for getting smooth poly outlines,
# gives circle and not random triangles
stripper = vtk.vtkStripper()
stripper.SetInputConnection(reader.GetOutputPort())
# Clipper for PLANE
clipper = vtk.vtkClipClosedSurface()
clipper.SetInputConnection(stripper.GetOutputPort())
clipper.SetClippingPlanes(planeC)
clipMapper = vtk.vtkImageFlip()
clipMapper = vtk.vtkPolyDataMapper()
clipMapper.SetInputConnection(clipper.GetOutputPort())
clipActor = vtk.vtkActor()
clipActor.SetMapper(clipMapper)
clipActor.GetProperty().SetColor(0.5,0.5,0.5)
clipActor.GetProperty().SetOpacity(0.5)
clipActor.SetPosition(0.001,0.001,0.001)
clipperOutline = vtk.vtkClipClosedSurface()
clipperOutline.SetInputConnection(stripper.GetOutputPort())
clipperOutline.SetClippingPlanes(planeC)
clipperOutline.GenerateFacesOff()
clipperOutline.GenerateOutlineOn()
innerNorms = vtk.vtkTriangleMeshPointNormals()
innerNorms.SetInputConnection(reader.GetOutputPort())
innerMapper = vtk.vtkOpenGLPolyDataMapper()
innerMapper.SetInputConnection(innerNorms.GetOutputPort())
innerActor = vtk.vtkActor()
innerActor.SetMapper(innerMapper)
clipperOutlineMapper = vtk.vtkPolyDataMapper()
clipperOutlineMapper.SetInputConnection(clipperOutline.GetOutputPort())
clipOutlineActor = vtk.vtkActor()
clipOutlineActor.SetMapper(clipperOutlineMapper)
clipOutlineActor.GetProperty().SetColor(0,1,0)
clipOutlineActor.SetPosition(0.001,0.001,0.001)
planeWidget = vtk.vtkImagePlaneWidget()
planeWidget.SetInputConnection(reader.GetOutputPort())
planeWidget.RestrictPlaneToVolumeOn()
planeWidget.GetResliceOutput()
rsx = planeWidget.GetResliceAxes()
#planeWidget.SetSliceIndex(52)
#planeWidget.SetOrigin(1,-1,-1)
planeWidget.SetResliceInterpolateToLinear()
self.clipActor = clipActor
self.planes = planes
self.planeWidget = planeWidget
self.innerActor = innerActor
self.clipOutlineActor = clipOutlineActor
px = planeWidget.GetSlicePosition()
#Cut(px)
#clipActor.VisibilityOn()
def UpdateMesh(obj, event):
obj.GetNormal()
self.planes.SetNormal(obj.GetNormal())
self.planes.SetOrigin(obj.GetOrigin())
self.clipActor.VisibilityOn()
#planeWidget.AddObserver("EndInteractionEvent", CutMesh)
planeWidget.AddObserver("InteractionEvent", UpdateMesh)
self.planeWidget = planeWidget
def testImagePlaneWidget(self):
"A more rigorous test using the image plane widget."
# This test is largely copied from
# Widgets/Python/TestImagePlaneWidget.py
# Load some data.
v16 = vtk.vtkVolume16Reader()
v16.SetDataDimensions(64, 64)
v16.SetDataByteOrderToLittleEndian()
v16.SetFilePrefix(os.path.join(Testing.VTK_DATA_ROOT,
"Data", "headsq", "quarter"))
v16.SetImageRange(1, 93)
v16.SetDataSpacing(3.2, 3.2, 1.5)
v16.Update()
xMin, xMax, yMin, yMax, zMin, zMax = v16.GetExecutive().GetWholeExtent(v16.GetOutputInformation(0))
img_data = v16.GetOutput()
spacing = img_data.GetSpacing()
sx, sy, sz = spacing
origin = img_data.GetOrigin()
ox, oy, oz = origin
# An outline is shown for context.
outline = vtk.vtkOutlineFilter()
outline.SetInputData(img_data)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# The shared picker enables us to use 3 planes at one time
# and gets the picking order right
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# The 3 image plane widgets are used to probe the dataset.
planeWidgetX = vtk.vtkImagePlaneWidget()
planeWidgetX.DisplayTextOn()
planeWidgetX.SetInputData(img_data)
planeWidgetX.SetPlaneOrientationToXAxes()
planeWidgetX.SetSliceIndex(32)
planeWidgetX.SetPicker(picker)
planeWidgetX.SetKeyPressActivationValue("x")
prop1 = planeWidgetX.GetPlaneProperty()
prop1.SetColor(1, 0, 0)
planeWidgetY = vtk.vtkImagePlaneWidget()
planeWidgetY.DisplayTextOn()
planeWidgetY.SetInputData(img_data)
planeWidgetY.SetPlaneOrientationToYAxes()
planeWidgetY.SetSliceIndex(32)
planeWidgetY.SetPicker(picker)
planeWidgetY.SetKeyPressActivationValue("y")
prop2 = planeWidgetY.GetPlaneProperty()
prop2.SetColor(1, 1, 0)
planeWidgetY.SetLookupTable(planeWidgetX.GetLookupTable())
# for the z-slice, turn off texture interpolation:
# interpolation is now nearest neighbour, to demonstrate
# cross-hair cursor snapping to pixel centers
planeWidgetZ = vtk.vtkImagePlaneWidget()
planeWidgetZ.DisplayTextOn()
planeWidgetZ.SetInputData(img_data)
planeWidgetZ.SetPlaneOrientationToZAxes()
planeWidgetZ.SetSliceIndex(46)
planeWidgetZ.SetPicker(picker)
planeWidgetZ.SetKeyPressActivationValue("z")
prop3 = planeWidgetZ.GetPlaneProperty()
prop3.SetColor(0, 0, 1)
planeWidgetZ.SetLookupTable(planeWidgetX.GetLookupTable())
# Now create another actor with an opacity < 1 and with some
# scalars.
p = vtk.vtkPolyData()
pts = vtk.vtkPoints()
pts.InsertNextPoint((0,0,0))
sc = vtk.vtkFloatArray()
sc.InsertNextValue(1.0)
p.SetPoints(pts)
p.GetPointData().SetScalars(sc)
m = vtk.vtkPolyDataMapper()
m.SetInputData(p)
# Share the lookup table of the widgets.
m.SetLookupTable(planeWidgetX.GetLookupTable())
m.UseLookupTableScalarRangeOn()
dummyActor = vtk.vtkActor()
dummyActor.SetMapper(m)
dummyActor.GetProperty().SetOpacity(0.0)
# Create the RenderWindow and Renderer
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren)
# Add the dummy actor.
ren.AddActor(dummyActor)
# Add the outline actor to the renderer, set the background
# color and size
ren.AddActor(outlineActor)
renWin.SetSize(600, 600)
ren.SetBackground(0.1, 0.1, 0.2)
current_widget = planeWidgetZ
mode_widget = planeWidgetZ
# Set the interactor for the widgets
iact = vtk.vtkRenderWindowInteractor()
iact.SetRenderWindow(renWin)
planeWidgetX.SetInteractor(iact)
planeWidgetX.On()
planeWidgetY.SetInteractor(iact)
planeWidgetY.On()
planeWidgetZ.SetInteractor(iact)
planeWidgetZ.On()
# Create an initial interesting view
ren.ResetCamera();
cam1 = ren.GetActiveCamera()
cam1.Elevation(110)
cam1.SetViewUp(0, 0, -1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iact.Initialize()
renWin.Render()
# Compare the images and test.
img_file = "TestImagePlaneWidget.png"
Testing.compareImage(renWin, Testing.getAbsImagePath(img_file))
# Interact if necessary.
if Testing.isInteractive():
iact.Start()
def BuildView(self):
if not self.vmtkRenderer:
self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
self.vmtkRenderer.Initialize()
self.OwnRenderer = 1
self.vmtkRenderer.RegisterScript(self)
if (self.ArrayName != ''):
self.Image.GetPointData().SetActiveScalars(self.ArrayName)
wholeExtent = self.Image.GetWholeExtent()
if self.Picker == None:
self.Picker = vtk.vtkCellPicker()
if self.PlaneWidgetX == None:
self.PlaneWidgetX = vtk.vtkImagePlaneWidget()
if self.PlaneWidgetY == None:
self.PlaneWidgetY = vtk.vtkImagePlaneWidget()
if self.PlaneWidgetZ == None:
self.PlaneWidgetZ = vtk.vtkImagePlaneWidget()
self.Picker.SetTolerance(0.005)
self.PlaneWidgetX.SetResliceInterpolateToLinear()
self.PlaneWidgetX.SetTextureInterpolate(self.TextureInterpolation)
self.PlaneWidgetX.SetUseContinuousCursor(self.ContinuousCursor)
self.PlaneWidgetX.SetInput(self.Image)
self.PlaneWidgetX.SetPlaneOrientationToXAxes()
self.PlaneWidgetX.SetSliceIndex(wholeExtent[0])
self.PlaneWidgetX.DisplayTextOn()
self.PlaneWidgetX.SetPicker(self.Picker)
self.PlaneWidgetX.KeyPressActivationOff()
self.PlaneWidgetX.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
if self.Margins:
self.PlaneWidgetX.SetMarginSizeX(0.05)
self.PlaneWidgetX.SetMarginSizeY(0.05)
else:
self.PlaneWidgetX.SetMarginSizeX(0.0)
self.PlaneWidgetX.SetMarginSizeY(0.0)
if self.WindowLevel[0] != 0.0:
self.PlaneWidgetX.SetWindowLevel(self.WindowLevel[0],self.WindowLevel[1])
self.PlaneWidgetX.On()
self.PlaneWidgetY.SetResliceInterpolateToLinear()
self.PlaneWidgetY.SetTextureInterpolate(self.TextureInterpolation)
self.PlaneWidgetY.SetUseContinuousCursor(self.ContinuousCursor)
self.PlaneWidgetY.SetInput(self.Image)
self.PlaneWidgetY.SetPlaneOrientationToYAxes()
self.PlaneWidgetY.SetSliceIndex(wholeExtent[2])
self.PlaneWidgetY.DisplayTextOn()
self.PlaneWidgetY.SetPicker(self.Picker)
self.PlaneWidgetY.KeyPressActivationOff()
self.PlaneWidgetY.SetLookupTable(self.PlaneWidgetX.GetLookupTable())
self.PlaneWidgetY.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
if self.Margins:
self.PlaneWidgetY.SetMarginSizeX(0.05)
self.PlaneWidgetY.SetMarginSizeY(0.05)
else:
self.PlaneWidgetY.SetMarginSizeX(0.0)
self.PlaneWidgetY.SetMarginSizeY(0.0)
if self.WindowLevel[0] != 0.0:
self.PlaneWidgetY.SetWindowLevel(self.WindowLevel[0],self.WindowLevel[1])
self.PlaneWidgetY.On()
self.PlaneWidgetZ.SetResliceInterpolateToLinear()
self.PlaneWidgetZ.SetTextureInterpolate(self.TextureInterpolation)
self.PlaneWidgetZ.SetUseContinuousCursor(self.ContinuousCursor)
self.PlaneWidgetZ.SetInput(self.Image)
self.PlaneWidgetZ.SetPlaneOrientationToZAxes()
self.PlaneWidgetZ.SetSliceIndex(wholeExtent[4])
self.PlaneWidgetZ.DisplayTextOn()
self.PlaneWidgetZ.SetPicker(self.Picker)
self.PlaneWidgetZ.KeyPressActivationOff()
self.PlaneWidgetZ.SetLookupTable(self.PlaneWidgetX.GetLookupTable())
self.PlaneWidgetZ.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
if self.Margins:
self.PlaneWidgetZ.SetMarginSizeX(0.05)
self.PlaneWidgetZ.SetMarginSizeY(0.05)
else:
self.PlaneWidgetZ.SetMarginSizeX(0.0)
self.PlaneWidgetZ.SetMarginSizeY(0.0)
if self.WindowLevel[0] != 0.0:
self.PlaneWidgetZ.SetWindowLevel(self.WindowLevel[0],self.WindowLevel[1])
self.PlaneWidgetZ.On()
if (self.Display == 1):
self.vmtkRenderer.Render()
if self.OwnRenderer:
self.vmtkRenderer.Deallocate()
render_window.SetSize(512, 512) render_window.AddRenderer(renderer) # Create an interactor interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(render_window) # # add your code here for MPR and the liver surface # # Help to get started... # picker = vtk.vtkCellPicker() # use same picker for all picker.SetTolerance(0.005) #X-CutPlane ipwx = vtk.vtkImagePlaneWidget() ipwx.SetPicker(picker) ipwx.SetInput(reader1.GetOutput()) ipwx.SetCurrentRenderer(renderer) ipwx.SetInteractor(interactor) ipwx.PlaceWidget() ipwx.SetPlaneOrientationToXAxes() ipwx.SetSliceIndex(W / 2) ipwx.DisplayTextOn() ipwx.EnabledOn() #Y-CutPlane ipwy = vtk.vtkImagePlaneWidget() ipwy.SetPicker(picker) ipwy.SetInput(reader1.GetOutput()) ipwy.SetCurrentRenderer(renderer)
def Panoramix():
selectedPlane1 = [0, 0, 0, 0]
selectedPlane2 = [0, 0, 0, 0]
def updateClippingPlane(obj, event):
obj.GetCursorData(selectedPlane1)
print("plane1: ", selectedPlane1)
# global clippingPlane
# Write some codes (ref to what you’ve done in step 2) # no more than two lines
clippingPlane.SetOrigin(obj.GetOrigin())
# clippingPlane.SetNormal(obj.GetNormal())
clippingPlane.Modified()
def updateClippingPlane2(obj, event):
obj.GetCursorData(selectedPlane2)
print("plane2: ", selectedPlane2)
# global clippingPlane2
# Write some codes (ref to what you’ve done in step 2) # no more than two lines
clippingPlane2.SetOrigin(obj.GetOrigin())
# clippingPlane2.SetNormal(obj.GetNormal())
clippingPlane2.Modified()
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(r"aneurysm.vti")
reader.Update()
data = reader.GetOutput()
image = vtk.vtkImageMathematics()
image.SetInput1Data(data)
image.SetConstantC(1024)
image.SetOperationToAddConstant()
image.Update()
output = image.GetOutput()
shifter = vtk.vtkImageShiftScale()
shifter.SetInputConnection(image.GetOutputPort())
shifter.SetOutputScalarTypeToUnsignedShort()
shifter.Update()
shifter2 = vtk.vtkImageShiftScale()
shifter2.SetInputConnection(image.GetOutputPort())
shifter2.SetOutputScalarTypeToInt()
shifter2.Update()
otf = vtk.vtkPiecewiseFunction()
ctf = vtk.vtkColorTransferFunction()
otf.RemoveAllPoints()
otf.AddPoint(image.GetOutput().GetScalarRange()[0] + 100, 0.0)
otf.AddPoint((image.GetOutput().GetScalarRange()[0] +
image.GetOutput().GetScalarRange()[1]) / 2, 0.3)
otf.AddPoint(image.GetOutput().GetScalarRange()[1], 1.0)
ctf.RemoveAllPoints()
ctf.AddRGBPoint(image.GetOutput().GetScalarRange()[0], 1, 1, 0)
ctf.AddRGBPoint(1250, 0.65, 0.7, 1.0)
ctf.AddRGBPoint(image.GetOutput().GetScalarRange()[1], 0, 0, 1)
propVolume = vtk.vtkVolumeProperty()
propVolume.ShadeOn()
propVolume.SetColor(ctf)
propVolume.SetScalarOpacity(otf)
propVolume.SetInterpolationTypeToLinear()
#rayCast = vtk.vtkVolumeRayCastCompositeFunction()
rayCast = vtk.vtkVolumeRayCastIsosurfaceFunction()
rayCast.SetIsoValue(1200)
#ayCast.SetCompositeMethodToInterpolateFirst()
#rayCast.SetCompositeMethodToClassifyFirst()
mapperVolume = vtk.vtkVolumeRayCastMapper()
mapperVolume.SetVolumeRayCastFunction(rayCast)
mapperVolume.SetInputConnection(shifter.GetOutputPort())
planeWidget = vtk.vtkImagePlaneWidget()
planeWidget.SetInputConnection(reader.GetOutputPort())
planeWidget.SetPlaneOrientationToZAxes()
planeWidget.SetSliceIndex(int(reader.GetOutput().GetDimensions()[2] / 2))
planeWidget.AddObserver("InteractionEvent", updateClippingPlane)
planeWidget2 = vtk.vtkImagePlaneWidget()
planeWidget2.SetInputConnection(reader.GetOutputPort())
planeWidget2.SetPlaneOrientationToZAxes()
planeWidget2.SetSliceIndex(
int(reader.GetOutput().GetDimensions()[2] - 15.0))
planeWidget2.AddObserver("InteractionEvent", updateClippingPlane2)
clippingPlane = vtk.vtkPlane()
clippingPlane.SetOrigin(planeWidget.GetOrigin())
clippingPlane.SetNormal(planeWidget.GetNormal())
clippingPlane2 = vtk.vtkPlane()
clippingPlane2.SetOrigin(planeWidget2.GetOrigin())
clippingPlane2.SetNormal([0, 0, -1]) #planeWidget2.GetNormal())
# mapperVolume.AddClippingPlane(clippingPlane)
# mapperVolume.AddClippingPlane(clippingPlane2)
# plane1: [79.0, 86.0, 59.0, 403.0]
# plane2: [123.0, 74.0, 104.0, 334.0]
pointOnPlane1 = [79.0, 86.0, 59.0, 403.0]
pointOnPlane2 = [123.0, 74.0, 104.0, 334.0]
# output = reader.GetOutput()
# points = output.GetPoints()
# array = output.GetData()
# numpy_nodes = vtk_to_numpy(image.GetOutput().GetPointData())
# print(numpy_nodes.shape)
# print(output.GetNumberOfPoints())
gtf = vtk.vtkPiecewiseFunction()
gtf.RemoveAllPoints()
gtf.AddPoint(image.GetOutput().GetScalarRange()[0], 0.0)
gtf.AddPoint((image.GetOutput().GetScalarRange()[0] +
image.GetOutput().GetScalarRange()[1]) / 2, 0.8)
gtf.AddPoint(image.GetOutput().GetScalarRange()[1], 1.0)
propVolume.SetGradientOpacity(gtf)
actorVolume = vtk.vtkVolume()
actorVolume.SetMapper(mapperVolume)
actorVolume.SetProperty(propVolume)
renderWindow = vtk.vtkRenderWindow()
renderer = vtk.vtkRenderer()
renderWindow.AddRenderer(renderer)
renderer.AddActor(actorVolume)
# renderer.SetBackground(1, 1, 1);
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renderWindow)
iren.Initialize()
planeWidget.SetInteractor(
iren) #render window interactor planeWidget.PlaceWidget()
planeWidget.On() # enable the interaction
planeWidget2.SetInteractor(
iren) #render window interactor planeWidget.PlaceWidget()
planeWidget2.On() # enable the interaction
renderWindow.Render()
iren.Start()
# Make interactive via callback function
# reader.Update()
# data = reader.GetOutput()
# data_range = data.GetScalarRange()
# print("data_range", data_range)
# imagemath = vtk.vtkImageMathematics()
# imagemath.SetInputConnection(reader.GetOutputPort())
# imagemath.SetConstantC(1024.0)
# imagemath.SetOperationToAddConstant()
# imagemath.Update()
# data = imagemath.GetOutput()
# data_range = data.GetScalarRange()
# print("data_range", data_range)
# #Contour
# #contour = vtk.vtkContourFilter()
# #contour.SetInputConnection(imagemath.GetOutputPort())
# #contour.SetValue(0, 2000)
# #contour.SetValue(1, 800)
# #contour.GenerateValues(3,1400, 2000)
# otf = vtk.vtkPiecewiseFunction()
# ctf = vtk.vtkColorTransferFunction()
# otf.RemoveAllPoints()
# otf.AddPoint(imagemath.GetOutput().GetScalarRange()[0]+100, 0.0)
# otf.AddPoint((imagemath.GetOutput().GetScalarRange()[0]+imagemath.GetOutput().GetScalarRange()[1])/2, 0.3)
# otf.AddPoint(imagemath.GetOutput().GetScalarRange()[1], 1.0)
# ctf.RemoveAllPoints()
# ctf.AddRGBPoint(imagemath.GetOutput().GetScalarRange()[0], 1, 1, 0)
# ctf.AddRGBPoint(1250, 0.65, 0.7, 1.0)
# ctf.AddRGBPoint(imagemath.GetOutput().GetScalarRange()[1], 0, 0, 1)
# propVolume = vtk.vtkVolumeProperty()
# propVolume.ShadeOn()
# propVolume.SetColor(ctf)
# propVolume.SetScalarOpacity(otf)
# propVolume.SetInterpolationTypeToLinear()
# #rayCast = vtk.vtkVolumeRayCastMIPFunction()
# rayCast = vtk.vtkVolumeRayCastIsosurfaceFunction()
# rayCast.SetIsoValue(1200)
# #rayCast = vtk.vtkVolumeRayCastCompositeFunction()
# #rayCast.SetCompositeMethodToInterpolateFirst()
# #rayCast.SetCompositeMethodToClassifyFirst()
# #We will need a mapper and an actor, let`s use the vtkPolyDataMapper and the vtkActor classes.
# #mapper = vtk.vtkPolyDataMapper()
# #mapper.SetInputConnection(contour.GetOutputPort())
# #mapper.ScalarVisibilityOff()
# shift = vtk.vtkImageShiftScale()
# shift.SetInputConnection(imagemath.GetOutputPort())
# shift.SetOutputScalarTypeToUnsignedShort()
# mapperVolume = vtk.vtkVolumeRayCastMapper()
# mapperVolume.SetVolumeRayCastFunction(rayCast)
# mapperVolume.SetInputConnection(shift.GetOutputPort())
# actorVolume = vtk.vtkVolume()
# actorVolume.SetMapper(mapperVolume)
# actorVolume.SetProperty(propVolume)
# gtf = vtk.vtkPiecewiseFunction()
# gtf.RemoveAllPoints()
# gtf.AddPoint(imagemath.GetOutput().GetScalarRange()[0], 0.0)
# gtf.AddPoint((imagemath .GetOutput().GetScalarRange()[0]+ imagemath.GetOutput().GetScalarRange()[1])/2, 0.8)
# gtf.AddPoint(imagemath.GetOutput().GetScalarRange()[1], 1.0)
# propVolume.SetGradientOpacity(gtf)
# # Define FIRST plane and clipping Plane
# planeWidget = vtk.vtkImagePlaneWidget()
# planeWidget.SetInputConnection(reader.GetOutputPort())
# planeWidget.SetPlaneOrientationToZAxes()
# #print("slice pos", planeWidget.GetSlicePosition())
# #print("go to ", planeWidget.GetSlicePosition()+410.0)
# #planeWidget.SetOrigin([-192.00000375, -318.00000375, -300.5])
# #print("slice pos", planeWidget.GetSlicePosition())
# #planeWidget.SetSliceIndex(0) #int(reader.GetOutput().GetDimensions()[2]/2))
# clippingPlane = vtk.vtkPlane()
# # print(planeWidget.GetOrigin())
# #clippingPlane.SetOrigin(planeWidget.GetOrigin())
# origin = [-192.00000375, -318.00000375, -300.5]
# clippingPlane.SetOrigin(origin)
# normal = [planeWidget.GetNormal()[0],planeWidget.GetNormal()[1],planeWidget.GetNormal()[2]]
# print("normal", normal)
# clippingPlane.SetNormal(normal)
# def updateClippingPlane(obj, event):
# print(obj.GetCurrentImageValue())
# #clippingPlane.SetOrigin(obj.GetOrigin())
# #lippingPlane.Modified()
# planeWidget.AddObserver("InteractionEvent", updateClippingPlane)
# # Define SECOND plane and clipping Plane
# ## planeWidget2 = vtk.vtkImagePlaneWidget()
# ## planeWidget2.SetInputConnection(reader.GetOutputPort())
# ## planeWidget2.SetPlaneOrientationToZAxes()
# ## planeWidget2.SetSliceIndex(int(reader.GetOutput().GetDimensions()[2]))
# ## print("normal:", planeWidget2.GetNormal())
# ## clippingPlane2 = vtk.vtkPlane()
# ## clippingPlane2.SetOrigin(planeWidget2.GetOrigin())
# ## normal = [planeWidget2.GetNormal()[0],planeWidget2.GetNormal()[1],-planeWidget2.GetNormal()[2]]
# ## print("normal mod:", normal)
# ## clippingPlane2.SetNormal(normal)
# ## def updateClippingPlane2(obj, event):
# ## clippingPlane2.SetOrigin(obj.GetOrigin())
# ## clippingPlane2.Modified()
# #planeWidget2.AddObserver("InteractionEvent", updateClippingPlane2)
# # Add planes to Mapper
# planes = vtk.vtkPlaneCollection()
# planes.AddItem(clippingPlane)
# ## planes.AddItem(clippingPlane2)
# mapperVolume.SetClippingPlanes(planes)
# #Let`s add our render window and an interactor:
# renderWindow = vtk.vtkRenderWindow()
# renderer = vtk.vtkRenderer()
# renderWindow.AddRenderer(renderer)
# renderer.AddActor(actorVolume)
# iren = vtk.vtkRenderWindowInteractor()
# iren.SetRenderWindow(renderWindow)
# iren.Initialize()
# ## planeWidget2.SetInteractor(iren)# render window interactor
# ## planeWidget2.PlaceWidget()
# ## planeWidget2.On() # enable the interaction
# planeWidget.SetInteractor(iren)# render window interactor
# planeWidget.PlaceWidget()
# planeWidget.On() # enable the interaction
# renderWindow.Render()
# iren.Start()
def Create(self):
plane_x = self.plane_x = vtk.vtkImagePlaneWidget()
plane_x.InteractionOff()
#Publisher.sendMessage('Input Image in the widget',
#(plane_x, 'SAGITAL'))
plane_x.SetPlaneOrientationToXAxes()
plane_x.TextureVisibilityOn()
plane_x.SetLeftButtonAction(0)
plane_x.SetRightButtonAction(0)
plane_x.SetMiddleButtonAction(0)
cursor_property = plane_x.GetCursorProperty()
cursor_property.SetOpacity(0)
plane_y = self.plane_y = vtk.vtkImagePlaneWidget()
plane_y.DisplayTextOff()
#Publisher.sendMessage('Input Image in the widget',
#(plane_y, 'CORONAL'))
plane_y.SetPlaneOrientationToYAxes()
plane_y.TextureVisibilityOn()
plane_y.SetLeftButtonAction(0)
plane_y.SetRightButtonAction(0)
plane_y.SetMiddleButtonAction(0)
prop1 = plane_y.GetPlaneProperty()
cursor_property = plane_y.GetCursorProperty()
cursor_property.SetOpacity(0)
plane_z = self.plane_z = vtk.vtkImagePlaneWidget()
plane_z.InteractionOff()
#Publisher.sendMessage('Input Image in the widget',
#(plane_z, 'AXIAL'))
plane_z.SetPlaneOrientationToZAxes()
plane_z.TextureVisibilityOn()
plane_z.SetLeftButtonAction(0)
plane_z.SetRightButtonAction(0)
plane_z.SetMiddleButtonAction(0)
cursor_property = plane_z.GetCursorProperty()
cursor_property.SetOpacity(0)
prop3 = plane_z.GetPlaneProperty()
prop3.SetColor(1, 0, 0)
selected_prop3 = plane_z.GetSelectedPlaneProperty()
selected_prop3.SetColor(1,0,0)
prop1 = plane_x.GetPlaneProperty()
prop1.SetColor(0, 0, 1)
selected_prop1 = plane_x.GetSelectedPlaneProperty()
selected_prop1.SetColor(0, 0, 1)
prop2 = plane_y.GetPlaneProperty()
prop2.SetColor(0, 1, 0)
selected_prop2 = plane_y.GetSelectedPlaneProperty()
selected_prop2.SetColor(0, 1, 0)
Publisher.sendMessage('Set Widget Interactor', plane_x)
Publisher.sendMessage('Set Widget Interactor', plane_y)
Publisher.sendMessage('Set Widget Interactor', plane_z)
self.Render()
def set_initial_display(self):
if self.renwininter is None:
self.renwininter = MEQ_QVTKRenderWindowInteractor(self.winsplitter)
self.renwininter.setWhatsThis(rendering_control_instructions)
self.renwin = self.renwininter.GetRenderWindow()
self.inter = self.renwin.GetInteractor()
self.winsplitter.insertWidget(0, self.renwininter)
self.winsplitter.addWidget(self.v_box_controls)
self.winsplitter.setSizes([500, 100])
self.renwininter.show()
# Paul Kemper suggested the following:
camstyle = vtk.vtkInteractorStyleTrackballCamera()
self.renwininter.SetInteractorStyle(camstyle)
self.extents = self.image_array.GetDataExtent()
self.spacing = self.image_array.GetDataSpacing()
self.origin = self.image_array.GetDataOrigin()
# An outline is shown for context.
if self.warped_surface:
self.index_selector.initWarpContextmenu()
sx, sy, sz = self.image_array.GetDataSpacing()
xMin, xMax, yMin, yMax, zMin, zMax = self.image_array.GetDataExtent(
)
xMin = sx * xMin
xMax = sx * xMax
yMin = sy * yMin
yMax = sy * yMax
self.scale_factor = 0.5 * (
(xMax - xMin) +
(yMax - yMin)) / (self.data_max - self.data_min)
zMin = self.data_min * self.scale_factor
zMax = self.data_max * self.scale_factor
self.outline = vtk.vtkOutlineSource()
self.outline.SetBounds(xMin, xMax, yMin, yMax, zMin, zMax)
else:
self.index_selector.init3DContextmenu()
self.outline = vtk.vtkOutlineFilter()
self.outline.SetInput(self.image_array.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInput(self.outline.GetOutput())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
# create blue to red color table
self.lut = vtk.vtkLookupTable()
self.lut.SetHueRange(0.6667, 0.0)
self.lut.SetNumberOfColors(256)
self.lut.Build()
# here is where the 2-D image gets warped
if self.warped_surface:
geometry = vtk.vtkImageDataGeometryFilter()
geometry.SetInput(self.image_array.GetOutput())
self.warp = vtk.vtkWarpScalar()
self.warp.SetInput(geometry.GetOutput())
self.warp.SetScaleFactor(self.scale_factor)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInput(self.warp.GetPolyDataOutput())
self.mapper.SetScalarRange(self.data_min, self.data_max)
self.mapper.SetLookupTable(self.lut)
self.mapper.ImmediateModeRenderingOff()
warp_actor = vtk.vtkActor()
# warp_actor.SetScale(2,1,1)
warp_actor.SetMapper(self.mapper)
min_range = 0.5 * self.scale_factor
max_range = 2.0 * self.scale_factor
self.index_selector.set_emit(False)
self.index_selector.setMaxValue(max_range, False)
self.index_selector.setMinValue(min_range)
self.index_selector.setTickInterval((max_range - min_range) / 10)
self.index_selector.setRange(max_range, False)
self.index_selector.setValue(self.scale_factor)
self.index_selector.setLabel('display gain')
self.index_selector.hideNDControllerOption()
self.index_selector.reset_scale_toggle()
self.index_selector.set_emit(True)
else:
# set up ImagePlaneWidgets ...
# The shared picker enables us to use 3 planes at one time
# and gets the picking order right
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# get locations for initial slices
xMin, xMax, yMin, yMax, zMin, zMax = self.extents
x_index = (xMax - xMin) / 2
y_index = (yMax - yMin) / 2
z_index = (zMax - zMin) / 2
# The 3 image plane widgets are used to probe the dataset.
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetX.DisplayTextOn()
self.planeWidgetX.SetInput(self.image_array.GetOutput())
self.planeWidgetX.SetPlaneOrientationToXAxes()
self.planeWidgetX.SetSliceIndex(x_index)
self.planeWidgetX.SetPicker(picker)
self.planeWidgetX.SetKeyPressActivationValue("x")
self.planeWidgetX.SetLookupTable(self.lut)
self.planeWidgetX.TextureInterpolateOff()
self.planeWidgetX.SetResliceInterpolate(0)
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetY.DisplayTextOn()
self.planeWidgetY.SetInput(self.image_array.GetOutput())
self.planeWidgetY.SetPlaneOrientationToYAxes()
self.planeWidgetY.SetSliceIndex(y_index)
self.planeWidgetY.SetPicker(picker)
self.planeWidgetY.SetKeyPressActivationValue("y")
self.planeWidgetY.SetLookupTable(
self.planeWidgetX.GetLookupTable())
self.planeWidgetY.TextureInterpolateOff()
self.planeWidgetY.SetResliceInterpolate(0)
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.planeWidgetZ.DisplayTextOn()
self.planeWidgetZ.SetInput(self.image_array.GetOutput())
self.planeWidgetZ.SetPlaneOrientationToZAxes()
self.planeWidgetZ.SetSliceIndex(z_index)
self.planeWidgetZ.SetPicker(picker)
self.planeWidgetZ.SetKeyPressActivationValue("z")
self.planeWidgetZ.SetLookupTable(
self.planeWidgetX.GetLookupTable())
self.planeWidgetZ.TextureInterpolateOff()
self.planeWidgetZ.SetResliceInterpolate(0)
self.current_widget = self.planeWidgetZ
self.mode_widget = self.planeWidgetZ
self.index_selector.set_emit(False)
self.index_selector.setMinValue(zMin)
self.index_selector.setMaxValue(zMax, False)
self.index_selector.setTickInterval((zMax - zMin) / 10)
self.index_selector.setRange(zMax, False)
self.index_selector.setValue(z_index)
self.index_selector.setLabel('Z axis')
self.index_selector.reset_scale_toggle()
self.index_selector.set_emit(True)
# create scalar bar for display of intensity range
self.scalar_bar = vtk.vtkScalarBarActor()
self.scalar_bar.SetLookupTable(self.lut)
self.scalar_bar.SetOrientationToVertical()
self.scalar_bar.SetWidth(0.1)
self.scalar_bar.SetHeight(0.8)
self.scalar_bar.SetTitle("Intensity")
self.scalar_bar.GetPositionCoordinate(
).SetCoordinateSystemToNormalizedViewport()
self.scalar_bar.GetPositionCoordinate().SetValue(0.01, 0.1)
# Create the RenderWindow and Renderer
self.ren = vtk.vtkRenderer()
self.renwin.AddRenderer(self.ren)
# Add the outline actor to the renderer, set the background color and size
if self.warped_surface:
self.ren.AddActor(warp_actor)
self.ren.AddActor(outlineActor)
self.ren.SetBackground(0.1, 0.1, 0.2)
self.ren.AddActor2D(self.scalar_bar)
# Create a text property for cube axes
tprop = vtk.vtkTextProperty()
tprop.SetColor(1, 1, 1)
tprop.ShadowOn()
# Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
# draw the axes. Add the actor to the renderer.
self.axes = vtk.vtkCubeAxesActor2D()
if self.warped_surface:
if zMin < 0.0 and zMax > 0.0:
zLoc = 0.0
else:
zLoc = zMin
self.axes.SetBounds(xMin, xMax, yMin, yMax, zLoc, zLoc)
self.axes.SetZLabel(" ")
else:
self.axes.SetInput(self.image_array.GetOutput())
self.axes.SetZLabel("Z")
self.axes.SetCamera(self.ren.GetActiveCamera())
self.axes.SetLabelFormat("%6.4g")
self.axes.SetFlyModeToOuterEdges()
self.axes.SetFontFactor(0.8)
self.axes.SetAxisTitleTextProperty(tprop)
self.axes.SetAxisLabelTextProperty(tprop)
self.axes.SetXLabel("X")
self.axes.SetYLabel("Y")
self.ren.AddProp(self.axes)
# Set the interactor for the widgets
if not self.warped_surface:
self.planeWidgetX.SetInteractor(self.inter)
self.planeWidgetX.On()
self.planeWidgetY.SetInteractor(self.inter)
self.planeWidgetY.On()
self.planeWidgetZ.SetInteractor(self.inter)
self.planeWidgetZ.On()
self.initialize_camera()
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(self.onLoadClicked)
exitAct = QAction('&Exit', self)
exitAct.setShortcut('ALT+F4')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(exitAct)
self.stack = Viewer2DStacked(self)
self.vtk_widgets = []
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
interactor = QVTKRenderWindowInteractor()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
# Create plane widgets
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
prop = pw.GetPlaneProperty()
renderLinesAsTubes(prop)
pw.SetPlaneProperty(prop)
prop = pw.GetSelectedPlaneProperty()
renderLinesAsTubes(prop)
pw.SetSelectedPlaneProperty(prop)
prop = pw.GetCursorProperty()
renderLinesAsTubes(prop)
pw.SetCursorProperty(prop)
pw.Modified()
self.planeWidget.append(pw)
self.establishCallbacks()
# Show widgets but hide non-existing data
for i in range(3):
self.stack.widget(i).show()
self.stack.widget(i).viewer.GetImageActor().SetVisibility(False)
# Layouts
vert_layout0 = QVBoxLayout()
horz_splitter0 = QSplitter(Qt.Horizontal)
horz_splitter0.addWidget(self.stack)
horz_splitter0.addWidget(self.vtk_widgets[0])
vert_layout0.addWidget(horz_splitter0)
vert_layout0.setContentsMargins(0, 0, 0, 0)
self.vtk_panel.setLayout(vert_layout0)
layout = QVBoxLayout()
self.btn = QPushButton("Next")
layout.addWidget(self.btn)
self.frame.setLayout(layout)
self.btn.clicked.connect(self.onPlaneClicked)
def addData(self, inputData):
"""Add inputData as a new layer.
"""
if inputData is None:
raise Exception, "Hallo, the inputData is none. Doing nothing."
# make sure it's vtkImageData
if hasattr(inputData, 'IsA') and inputData.IsA('vtkImageData'):
# if we already have this data as input, we can't take it
for ipw in self._ipws:
if inputData is ipw.GetInput():
raise Exception,\
"This inputData already exists in this slice."
# make sure it's all up to date
inputData.Update()
if self._ipws:
# this means we already have data and what's added now can
# only be allowed as overlay
# now check if the new data classifies as overlay
mainInput = self._ipws[0].GetInput()
if inputData.GetWholeExtent() != mainInput.GetWholeExtent():
raise Exception, \
"The extent of this inputData " \
"does not match the extent of the existing input" \
", so it can't be used as overlay:\n"\
"[%s != %s]" % \
(inputData.GetWholeExtent(),
mainInput.GetWholeExtent())
# differences in spacing between new input and existing input
spacingDiff = [
abs(i - j) for (i, j) in zip(inputData.GetSpacing(),
mainInput.GetSpacing())
]
# maximal allowable difference
spacingEpsilon = 0.0001
if spacingDiff[0] > spacingEpsilon or \
spacingDiff[1] > spacingEpsilon or \
spacingDiff[2] > spacingEpsilon:
raise Exception, \
"The spacing of this inputData " \
"does not match the spacing of the existing input" \
", so it can't be used as overlay.\n"\
"[%s != %s]" % \
(inputData.GetSpacing(),
mainInput.GetSpacing())
self._ipws.append(vtk.vtkImagePlaneWidget())
try:
# with invalid data, this will throw an exception!
self._ipws[-1].SetInput(inputData)
except RuntimeError, e:
# so we undo any changes so far, and re-raise the exception
# calling code will then not make any accounting changes, so
# no harm done.
self._ipws[-1].SetInput(None)
del self._ipws[-1]
raise
self._ipws[-1].UserControlledLookupTableOn()
self._ipws[-1].SetResliceInterpolateToNearestNeighbour()
# now make sure they have the right lut and are synched
# with the main IPW
self._resetOverlays()
if self._orthoViewFrame:
# also update our orthoView
self._createOrthoPipelineForNewIPW(self._ipws[-1])
self._syncOrthoView()
self._orthoViewFrame.RWI.Render()
# if self._ipws ...
else:
# this means primary data!
self._ipws.append(vtk.vtkImagePlaneWidget())
#self._ipws[-1].GetPolyDataAlgorithm().SetXResolution(64)
#self._ipws[-1].GetPolyDataAlgorithm().SetYResolution(64)
try:
# with invalid data, this will throw an exception!
self._ipws[-1].SetInput(inputData)
except RuntimeError, e:
# so we undo any changes so far, and re-raise the exception
# calling code will then not make any accounting changes, so
# no harm done.
self._ipws[-1].SetInput(None)
del self._ipws[-1]
raise
self._ipws[-1].SetPicker(self.sliceDirections.ipwPicker)
# GetColorMap() -- new VTK CVS
self._ipws[-1].GetColorMap().SetOutputFormatToRGB()
#self._ipws[-1].GetImageMapToColors().SetOutputFormatToRGB()
# now make callback for the ipw
self._ipws[-1].AddObserver(
'StartInteractionEvent',
lambda e, o: self._ipwStartInteractionCallback())
self._ipws[-1].AddObserver(
'InteractionEvent',
lambda e, o: self._ipwInteractionCallback())
self._ipws[-1].AddObserver(
'EndInteractionEvent',
lambda e, o: self._ipwEndInteractionCallback())
self._resetPrimary()
# now let's update our orthoView as well (if applicable)
if self._orthoViewFrame:
self._createOrthoPipelineForNewIPW(self._ipws[-1])
# and because it's a primary, we have to reset as well
# self._resetOrthoView() also calls self.SyncOrthoView()
self._resetOrthoView()
self._orthoViewFrame.Render()
# also check for contourObjects (primary data is being added)
self.addAllContourObjects()
# make sure our output polydata is in sync with the new prim
self._syncOutputPolyData()
# first we name ourselves... (ImageReslice loses the input
# scalars name)
rsoPD = self._ipws[-1].GetResliceOutput().GetPointData()
rsoScalars = rsoPD.GetScalars()
if rsoScalars:
if rsoScalars.GetName():
print "sliceDirection.py: WARNING - ResliceOutput " \
"scalars are named."
else:
rsoScalars.SetName('ipw_reslice_output')
# and add ourselvess to the output unstructured grid pointer
self.sliceDirections.ipwAppendFilter.AddInput(
self._ipws[-1].GetResliceOutput())
def __init__(self, rwi, renderer):
# nnsmit-edit
self.overlay_active = 0;
self.overlay_active_voxels = 0;
self.overlay_active_100band1 = 0;
self.overlay_active_100band2 = 0;
self.overlay_active_100band3 = 0;
self.overlay_active_50band1 = 0;
self.overlay_active_50band2 = 0;
self.overlay_active_50band3 = 0;
# end edit
self.rwi = rwi
self.renderer = renderer
istyle = vtk.vtkInteractorStyleTrackballCamera()
rwi.SetInteractorStyle(istyle)
# we unbind the existing mousewheel handler so it doesn't
# interfere
rwi.Unbind(wx.EVT_MOUSEWHEEL)
rwi.Bind(wx.EVT_MOUSEWHEEL, self._handler_mousewheel)
self.ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.ipws[0].GetLookupTable()
for ipw in self.ipws:
ipw.SetInteractor(rwi)
ipw.SetLookupTable(lut)
# IPWS for overlay
self.overlay_ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.overlay_ipws[0].GetLookupTable()
lut.SetNumberOfTableValues(3)
lut.SetTableValue(0,0,0,0,0)
lut.SetTableValue(1,0.5,0,1,1)
lut.SetTableValue(2,1,0,0,1)
lut.Build()
for ipw_overlay in self.overlay_ipws:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for voxels selected in scatterplot
self.overlay_ipws_voxels = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.overlay_ipws_voxels[0].GetLookupTable()
lut.SetNumberOfTableValues(3)
lut.SetTableValue(0,0,0,0,0)
lut.SetTableValue(1,0.5,0,1,1)
lut.SetTableValue(2,1,0,0,1)
lut.Build()
for ipw_overlay in self.overlay_ipws_voxels:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 100%band in first row
self.overlay_ipws_100band1 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut1 = self.overlay_ipws_100band1[0].GetLookupTable()
lut1.SetNumberOfTableValues(3)
lut1.SetTableValue(0,0,0,0,0)
lut1.SetTableValue(1, 1, 1, 0, 1)
lut1.SetTableValue(2, 1,1,0, 1)
lut1.Modified()
lut1.Build()
for ipw_overlay in self.overlay_ipws_100band1:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut1)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 50%band in first row
self.overlay_ipws_50band1 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut1 = self.overlay_ipws_50band1[0].GetLookupTable()
lut1.SetNumberOfTableValues(3)
lut1.SetTableValue(0,0,0,0,0)
lut1.SetTableValue(1, 1, 1, 0, 1)
lut1.SetTableValue(2, 1,1,0, 1)
lut1.Modified()
lut1.Build()
for ipw_overlay in self.overlay_ipws_50band1:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut1)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 100%band in second row
self.overlay_ipws_100band2 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
#lut2 = self.overlay_ipws_100band2[0].GetLookupTable()
#lut2.SetNumberOfTableValues(3)
#lut2.SetTableValue(0,0,0,0,0)
#lut2.SetTableValue(1, 0.98,0,0, 0.37)
#lut2.SetTableValue(2, 0.98,0,0, 0.37)
#lut2.Modified()
#lut2.Build()
for ipw_overlay in self.overlay_ipws_100band2:
ipw_overlay.SetInteractor(rwi)
#ipw_overlay.SetLookupTable(lut2)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 100%band in second row
self.overlay_ipws_50band2 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
#lut2 = self.overlay_ipws_100band2[0].GetLookupTable()
#lut2.SetNumberOfTableValues(3)
#lut2.SetTableValue(0,0,0,0,0)
#lut2.SetTableValue(1, 0.98,0,0, 0.37)
#lut2.SetTableValue(2, 0.98,0,0, 0.37)
#lut2.Modified()
#lut2.Build()
for ipw_overlay in self.overlay_ipws_50band2:
ipw_overlay.SetInteractor(rwi)
#ipw_overlay.SetLookupTable(lut2)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 100%band in third row
self.overlay_ipws_100band3 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut3 = self.overlay_ipws_100band3[0].GetLookupTable()
lut3.SetNumberOfTableValues(3)
lut3.SetTableValue(0,0,0,0,0)
lut3.SetTableValue(1,0,0.643,0.941, 0.5)
lut3.SetTableValue(2,0,0.643,0.941, 0.5)
lut3.Modified()
lut3.Build()
for ipw_overlay in self.overlay_ipws_100band3:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut3)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# IPWS for overlay of 50%band in third row
self.overlay_ipws_50band3 = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut3 = self.overlay_ipws_50band3[0].GetLookupTable()
lut3.SetNumberOfTableValues(3)
lut3.SetTableValue(0,0,0,0,0)
lut3.SetTableValue(1,0,0.643,0.941, 0.5)
lut3.SetTableValue(2,0,0.643,0.941, 0.5)
lut3.Modified()
lut3.Build()
for ipw_overlay in self.overlay_ipws_50band3:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut3)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# now actually connect the sync_overlay observer
for i,ipw in enumerate(self.ipws):
ipw.AddObserver('InteractionEvent',lambda vtk_o, vtk_e, i=i: self.observer_sync_overlay(self.ipws,i))
# end edit
# we only set the picker on the visible IPW, else the
# invisible IPWs block picking!
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.ipws[0].SetPicker(self.picker)
self.outline_source = vtk.vtkOutlineCornerFilter()
m = vtk.vtkPolyDataMapper()
m.SetInput(self.outline_source.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
a.PickableOff()
self.outline_actor = a
self.dv_orientation_widget = DVOrientationWidget(rwi)
# this can be used by clients to store the current world
# position
self.current_world_pos = (0,0,0)
self.current_index_pos = (0,0,0)
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(self.onLoadClicked)
exitAct = QAction('&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(exitAct)
self.vtk_widgets = [Viewer2D(self.vtk_panel, 0),
Viewer2D(self.vtk_panel, 1),
Viewer2D(self.vtk_panel, 2)]
# Make all views share the same cursor object
for i in range(3):
self.vtk_widgets[i].viewer.SetResliceCursor(self.vtk_widgets[0].viewer.GetResliceCursor())
if use3D:
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
# In c++ we create generic opengl renderwindow and replace that of
# the window - can we do that and not use QVTKRenderWindowInteractor
interactor = QVTKRenderWindowInteractor()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
self.planeWidget.append(pw)
for i in range(3):
color = [0.0, 0.0, 0.0]
color[i] = 1
for j in range(3):
color[j] = color[j] / 4.0
self.vtk_widgets[i].viewer.GetRenderer().SetBackground(color)
self.vtk_widgets[i].interactor.Disable()
self.establishCallbacks()
for i in range(3):
self.vtk_widgets[i].show()
for i in range(3):
self.vtk_widgets[i].viewer.GetImageActor().SetVisibility(False)
# Layouts
horz_layout0 = QHBoxLayout()
vert_splitter = QSplitter(Qt.Vertical)
horz_splitter0 = QSplitter(Qt.Horizontal)
horz_splitter0.addWidget(self.vtk_widgets[0])
horz_splitter0.addWidget(self.vtk_widgets[1])
vert_splitter.addWidget(horz_splitter0)
horz_splitter1 = QSplitter(Qt.Horizontal)
horz_splitter1.addWidget(self.vtk_widgets[2])
if use3D:
horz_splitter1.addWidget(self.vtk_widgets[3])
vert_splitter.addWidget(horz_splitter1)
horz_layout0.addWidget(vert_splitter)
horz_layout0.setContentsMargins(0, 0, 0, 0)
self.vtk_panel.setLayout(horz_layout0)
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(lambda: self.onLoadClicked(0))
surfAct = QAction('&Open Surface', self)
surfAct.setShortcut('Ctrl+S')
surfAct.setStatusTip('Surf data')
surfAct.triggered.connect(lambda: self.onLoadClicked(1))
exitAct = QAction('&Exit', self)
exitAct.setShortcut('ALT+F4')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(surfAct)
fileMenu.addAction(exitAct)
self.vtk_widgets = [
Viewer2D(self.vtk_panel, 0),
Viewer2D(self.vtk_panel, 1),
Viewer2D(self.vtk_panel, 2)
]
# Make all views share the same cursor object
for i in range(3):
self.vtk_widgets[i].viewer.SetResliceCursor(
self.vtk_widgets[0].viewer.GetResliceCursor())
# Cursor representation (anti-alias)
for i in range(3):
for j in range(3):
prop = self.vtk_widgets[i].viewer.GetResliceCursorWidget(
).GetResliceCursorRepresentation().GetResliceCursorActor(
).GetCenterlineProperty(j)
renderLinesAsTubes(prop)
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
interactor = QVTKRenderWindowInteractor()
# Gradient background
ren.SetBackground(245.0 / 255.0, 245.0 / 255.0, 245.0 / 255.0)
ren.SetBackground2(170.0 / 255.0, 170.0 / 255.0, 170.0 / 255.0)
ren.GradientBackgroundOn()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
# Create plane widgets
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
prop = pw.GetPlaneProperty()
renderLinesAsTubes(prop)
pw.SetPlaneProperty(prop)
prop = pw.GetSelectedPlaneProperty()
renderLinesAsTubes(prop)
pw.SetSelectedPlaneProperty(prop)
prop = pw.GetCursorProperty()
renderLinesAsTubes(prop)
pw.SetCursorProperty(prop)
prop = pw.GetTextProperty()
prop.SetColor(black)
pw.Modified()
# Set background for 2D views
for j in range(3):
color[j] = color[j] / 4.0
self.vtk_widgets[i].viewer.GetRenderer().SetBackground(color)
self.vtk_widgets[i].interactor.Disable()
self.planeWidget.append(pw)
# Annotation
cornerAnnotation = vtk.vtkCornerAnnotation()
cornerAnnotation.SetLinearFontScaleFactor(2)
cornerAnnotation.SetNonlinearFontScaleFactor(1)
cornerAnnotation.SetMaximumFontSize(20)
cornerAnnotation.SetText(vtk.vtkCornerAnnotation.UpperLeft, '3D')
cornerAnnotation.GetTextProperty().SetColor(1, 1, 1)
cornerAnnotation.SetWindowLevel(
self.vtk_widgets[0].viewer.GetWindowLevel())
ren.AddViewProp(cornerAnnotation)
self.establishCallbacks()
# Show widgets but hide non-existing data
for i in range(3):
self.vtk_widgets[i].show()
self.vtk_widgets[i].viewer.GetImageActor().SetVisibility(False)
# Layouts
horz_layout0 = QHBoxLayout()
vert_splitter = QSplitter(Qt.Vertical)
horz_splitter0 = QSplitter(Qt.Horizontal)
horz_splitter0.addWidget(self.vtk_widgets[0])
horz_splitter0.addWidget(self.vtk_widgets[1])
vert_splitter.addWidget(horz_splitter0)
horz_splitter1 = QSplitter(Qt.Horizontal)
horz_splitter1.addWidget(self.vtk_widgets[2])
horz_splitter1.addWidget(self.vtk_widgets[3])
vert_splitter.addWidget(horz_splitter1)
horz_layout0.addWidget(vert_splitter)
horz_layout0.setContentsMargins(0, 0, 0, 0)
self.vtk_panel.setLayout(horz_layout0)
vert_layout = QVBoxLayout()
# Sagittal/Coronal/Axial planes - not used
horz_layout1 = QHBoxLayout()
self.btnSagittal = QPushButton("S")
self.btnSagittal.setCheckable(True)
self.btnSagittal.setChecked(True)
horz_layout1.addWidget(self.btnSagittal)
self.btnCoronal = QPushButton("C")
self.btnCoronal.setCheckable(True)
self.btnCoronal.setChecked(True)
horz_layout1.addWidget(self.btnCoronal)
self.btnAxial = QPushButton("A")
self.btnAxial.setCheckable(True)
self.btnAxial.setChecked(True)
horz_layout1.addWidget(self.btnAxial)
self.btnSagittal.clicked.connect(self.togglePlanes)
self.btnCoronal.clicked.connect(self.togglePlanes)
self.btnAxial.clicked.connect(self.togglePlanes)
verticalSpacer = QSpacerItem(10, 10, QSizePolicy.Minimum,
QSizePolicy.Expanding)
vert_layout.addSpacerItem(verticalSpacer)
# Misalignment
groupBox = QGroupBox("Misalignment")
vert_layout.addWidget(groupBox)
mis_layout = QVBoxLayout()
# Local and reset
horzSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.btnLocal = QCheckBox("local")
self.btnReset = QPushButton("Reset")
self.btnReset.clicked.connect(self.onResetOffset)
# Misalignment buttons
horz_layout4 = QHBoxLayout()
horz_layout4.addWidget(self.btnLocal)
horz_layout4.addSpacerItem(horzSpacer)
horz_layout4.addWidget(self.btnReset)
mis_layout.addItem(horz_layout4)
# Misalignment sliders
[(self.sliderTX, self.btnTransX), (self.sliderTY, self.btnTransY),
(self.sliderTZ, self.btnTransZ), (self.sliderRX, self.btnRotX),
(self.sliderRY, self.btnRotY), (self.sliderRZ, self.btnRotZ)
] = self.createMisAlignment(mis_layout, self.onOrientationClicked)
groupBox.setLayout(mis_layout)
# Movement
groupBox = QGroupBox("Movement")
vert_layout.addWidget(groupBox)
groupLayout = QVBoxLayout()
# Local and reset
horzSpacer = QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Minimum)
# TODO: Return values
self.btnMoveLocal = QCheckBox("local")
self.btnReset1 = QPushButton("Reset")
self.btnReset1.clicked.connect(self.onResetMovement)
# Movement sliders
layout = QHBoxLayout()
layout.addWidget(self.btnMoveLocal)
layout.addSpacerItem(horzSpacer)
layout.addWidget(self.btnReset1)
groupLayout.addItem(layout)
[
(self.sliderMTX, self.sliderMTY, self.sliderMTZ),
(self.sliderMRX, self.sliderMRY, self.sliderMRZ)
] = self.createMovement(groupLayout, self.onSliderPressed, self.onMove)
groupBox.setLayout(groupLayout)
self.frame.setLayout(vert_layout)
table.SetValueRange(0, 1)
table.SetHueRange(0.0, 1.0)
table.SetSaturationRange(0.0, 0.0)
mapToColors = vtk.vtkImageMapToColors()
mapToColors.SetInputConnection(reader.GetOutputPort())
mapToColors.SetLookupTable(table)
mapToColors.Update()
# A picker is used to get information about the volume
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# Define plane widgets for x, y and z
planeWidgetX= vtk.vtkImagePlaneWidget()
# Set plane properties
planeWidgetX.SetInput(mapToColors.GetOutput())
planeWidgetX.SetPlaneOrientationToXAxes()
planeWidgetX.DisplayTextOn()
planeWidgetX.SetSliceIndex(100)
planeWidgetX.SetPicker(picker)
planeWidgetX.SetLookupTable(table)
planeWidgetX.SetColorMap(mapToColors)
planeWidgetX.SetKeyPressActivationValue("x")
planeWidgetX.GetPlaneProperty().SetColor(RGB_tuples[0])
# Place plane widget and set interactor
planeWidgetX.SetCurrentRenderer(ren)
planeWidgetX.SetInteractor(iren)
def createVisualization(self):
if self.alreadyCall:
return
self.alreadyCall = True
global renderer, renderWindow, renderWindowInteractor, reader, reader_Bones, reader_Blood, reader_Skin, isovalue, BonesMapper, BonesActor, BloodActor, BloodMapper, SkinActor, SkinMapper, volume, volumeMapper, ClippingPlane, ImagePlane, iss, ctf
renderWindow = self.getView('-1')
renderer = renderWindow.GetRenderers().GetFirstRenderer()
# Read the volumetric image
filename_vol = "CT.vtk"
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename_vol)
reader.Update()
# Read the meshes
filename_mesh = "Bones.obj"
reader_Bones = vtk.vtkOBJReader()
reader_Bones.SetFileName(filename_mesh)
reader_Bones.Update()
filename_mesh = "Skin.obj"
reader_Skin = vtk.vtkOBJReader()
reader_Skin.SetFileName(filename_mesh)
reader_Skin.Update()
filename_mesh = "Blood.obj"
reader_Blood = vtk.vtkOBJReader()
reader_Blood.SetFileName(filename_mesh)
reader_Blood.Update()
# Shift and scale input data between 0 and 255
range = 255
a, b = reader.GetOutput().GetScalarRange()
iss = vtk.vtkImageShiftScale()
iss.SetInputData(reader.GetOutput())
iss.SetShift(-a)
iss.SetScale(range / (b - a))
iss.SetOutputScalarTypeToUnsignedChar()
# Volume mapper
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(iss.GetOutputPort())
volumeMapper.SetBlendModeToIsoSurface()
####################### COLOR FUNCTION #######################
colorTransferFunction = vtk.vtkColorTransferFunction()
#Background
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
#Lungs
colorTransferFunction.AddRGBPoint(30.0, 0.9059, 0.6314, 0.6902)
colorTransferFunction.AddRGBPoint(40.0, 0.9059, 0.6314, 0.6902)
#General Tissue
colorTransferFunction.AddRGBPoint(50, 1.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(60, 1.0, 1.0, 0.0)
#Cardiac Tissue 1.0000 0.3882 0.2784
colorTransferFunction.AddRGBPoint(61.0, 1.0, 0.3882, 0.2784)
colorTransferFunction.AddRGBPoint(75.0, 1.0, 0.3882, 0.2784)
#Blood
colorTransferFunction.AddRGBPoint(85, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(105, 1.0, 0.0, 0.0)
#Bones
colorTransferFunction.AddRGBPoint(110, 1.0, 1.0, 1.0)
####################### OPACITY FUNCTION #######################
opacityTransferFunction_ct = vtk.vtkPiecewiseFunction()
#Background
opacityTransferFunction_ct.AddPoint(25.0, 0.0)
#Lungs
opacityTransferFunction_ct.AddPoint(30.0, 0.0)
opacityTransferFunction_ct.AddPoint(40.0, 0.0)
opacityTransferFunction_ct.AddPoint(40.1, 0.1)
#General Tissue
opacityTransferFunction_ct.AddPoint(50.0, 0.05)
opacityTransferFunction_ct.AddPoint(64.0, 0.05)
# Cardiac Tissue
opacityTransferFunction_ct.AddPoint(65.0, 1)
opacityTransferFunction_ct.AddPoint(75.0, 1)
# Blood
opacityTransferFunction_ct.AddPoint(85.0, 0.03)
opacityTransferFunction_ct.AddPoint(100.0, 0.03)
#Bones
opacityTransferFunction_ct.AddPoint(110.0, 0.5)
####################### GRADIENT FUNCTION #######################
val_grad = 0
gradient_function_ct = vtk.vtkPiecewiseFunction()
gradient_function_ct.AddPoint(val_grad, 1.0)
####################### VOLUME #######################
#Properties
isovalue = 75.0
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.GetIsoSurfaceValues().SetValue(0, isovalue)
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction_ct)
volumeProperty.SetGradientOpacity(gradient_function_ct)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
#Volume
volume = self.volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.VisibilityOn()
# Mesh Mappers and actors
BonesMapper = vtk.vtkPolyDataMapper()
BonesActor = vtk.vtkActor()
BonesMapper.SetInputConnection(reader_Bones.GetOutputPort())
BonesActor.SetMapper(BonesMapper)
BonesActor.GetProperty().SetColor(0.93, 0.92, 0.756)
BonesActor.GetProperty().SetOpacity(0.9)
BloodMapper = vtk.vtkPolyDataMapper()
BloodActor = vtk.vtkActor()
BloodMapper.SetInputConnection(reader_Blood.GetOutputPort())
BloodActor.SetMapper(BloodMapper)
BloodActor.GetProperty().SetColor(1.0, 0, 0)
SkinMapper = vtk.vtkPolyDataMapper()
SkinActor = vtk.vtkActor()
SkinMapper.SetInputConnection(reader_Skin.GetOutputPort())
SkinActor.SetMapper(SkinMapper)
SkinActor.GetProperty().SetColor(1.0, 0.8, 0.8)
SkinActor.GetProperty().SetOpacity(0.6)
# Renderer & renderWindow
renderer.AddVolume(volume)
renderer.AddActor(BonesActor)
renderer.AddActor(SkinActor)
renderer.AddActor(BloodActor)
# Clipping ImagePlane
ClippingPlane = vtk.vtkPlane()
ClippingPlane.SetNormal([1.0, 0.0, 0.0])
xmin, xmax, ymin, ymax, zmin, zmax = volume.GetBounds()
ClippingPlane.SetOrigin((xmin + xmax) / 2, (ymin + ymax) / 2,
(zmin + zmax) / 2)
volumeMapper.AddClippingPlane(ClippingPlane)
volume.Update()
# Outline
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(reader.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
outline.GetProperty().SetColor(1.0, 1.0, 0.0)
renderer.AddActor(outline)
# Cutter
BonesMapper.AddClippingPlane(ClippingPlane)
SkinMapper.AddClippingPlane(ClippingPlane)
BloodMapper.AddClippingPlane(ClippingPlane)
####################### CREATE PLANES #######################
# Grayscale Colormap
ctf = vtk.vtkLookupTable()
ctf.SetTableRange(0, 1)
ctf.SetHueRange(1.0, 1.0)
ctf.SetSaturationRange(0.0, 0.0)
ctf.SetValueRange(0, 1)
ctf.Build()
# Window Interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle(
).SetCurrentStyleToTrackballCamera()
renderWindowInteractor.EnableRenderOff()
# ImagePlane
ImagePlane = vtk.vtkImagePlaneWidget()
ImagePlane.SetInputConnection(iss.GetOutputPort())
ImagePlane.SetPlaneOrientationToXAxes()
ImagePlane.SetLookupTable(ctf)
ImagePlane.SetSlicePosition(int((ymax + ymin) / 2))
# ImagePlane.SetPicker(picker)
ImagePlane.DisplayTextOn()
ImagePlane.SetInteractor(renderWindowInteractor)
ImagePlane.EnabledOn()
ImagePlane.SetLeftButtonAction(1)
ImagePlane.SetMiddleButtonAction(0)
def ImagePlaneScript(obj, event):
ClipPlaneOrigin = tuple(
map(sum,
zip(obj.GetOrigin(), tuple(-i for i in obj.GetNormal()))))
ClippingPlane.SetOrigin(ClipPlaneOrigin)
ClippingPlane.SetNormal(obj.GetNormal())
ImagePlane.AddObserver('InteractionEvent', ImagePlaneScript)
ImagePlane.InteractionOn()
# Renderer & render window
renderer.ResetCamera()
renderWindow.Render()
return self.resetCamera()
table.SetValueRange(0, 1)
table.SetHueRange(0.0, 1.0)
table.SetSaturationRange(0.0, 0.0)
mapToColors = vtk.vtkImageMapToColors()
mapToColors.SetInputConnection(reader.GetOutputPort())
mapToColors.SetLookupTable(table)
mapToColors.Update()
# A picker is used to get information about the volume
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
# Define plane widgets for x, y and z
planeWidgetX, planeWidgetY, planeWidgetZ = [
vtk.vtkImagePlaneWidget() for i in range(3)
]
# Set plane properties
for plane, axtext, wgtcolor, ind in zip(
(planeWidgetX, planeWidgetY, planeWidgetZ), ("x", "y", "z"),
((0.5, 0, 0.5), (0.5, 0.5, 0), (0, 0.5, 0.5)), range(3)):
plane.SetInputConnection(reader.GetOutputPort())
plane.SetPlaneOrientation(ind)
plane.DisplayTextOn()
plane.SetSliceIndex(100)
plane.SetPicker(picker)
plane.SetLookupTable(table)
plane.SetColorMap(mapToColors)
plane.SetKeyPressActivationValue(axtext)
prop = plane.GetPlaneProperty()
def renderVolume(self, vtkWidget):
#def renderVolume(self,vtkWidget,vtkWidgetXY):
#self.readVolume(loadedDataInfo)
# The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be
# completly opaque whereas the three different cubes are given different transperancy-values to show how it works.
self.alphaChannelFunc = vtk.vtkPiecewiseFunction()
self.alphaChannelFunc.AddPoint(self.cMin, 0)
self.alphaChannelFunc.AddPoint(self.cMax, 1)
# This class stores color data and can create color tables from a few color points.
self.colorFunc = vtk.vtkColorTransferFunction()
self.histWidg = HistogramWidget()
self.histWidg.setColorMap(
self.colorFunc, 'viridis', self.cMin,
self.cMax) # This function set the vslues for color function
# The preavius two classes stored properties. Because we want to apply these properties to the volume we want to render,
# we have to store them in a class that stores volume prpoperties.
self.volumeProperty = vtk.vtkVolumeProperty()
self.volumeProperty.SetColor(self.colorFunc)
self.volumeProperty.SetScalarOpacity(self.alphaChannelFunc)
# This class describes how the volume is rendered (through ray tracing).
self.compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
# We can finally create our volume. We also have to specify the data for it, as well as how the data will be rendered.
self.volumeMapper = vtk.vtkVolumeRayCastMapper()
self.volumeMapper.SetVolumeRayCastFunction(self.compositeFunction)
self.volumeMapper.SetInput(self.reader.GetOutput())
# The class vtkVolume is used to pair the preaviusly declared volume as well as the properties to be used when rendering that volume.
self.volume = vtk.vtkVolume()
self.volume.SetMapper(self.volumeMapper)
self.volume.SetProperty(self.volumeProperty)
# With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application
self.renderer = vtk.vtkRenderer()
self.renderWin = vtkWidget.GetRenderWindow()
self.renderWin.AddRenderer(self.renderer)
self.renderInteractor = vtkWidget.GetRenderWindow().GetInteractor()
self.renderInteractor.SetRenderWindow(self.renderWin)
# We add the volume to the renderer ...
self.renderer.AddVolume(self.volume)
# ... set background color to gray ...
self.renderer.SetBackground(0.321, 0.349, 0.435)
# ... and set window size.
#self.renderWin.SetSize(800,800) # in the UI of PMainWindow we have set "auto fill background" property of QVTKWidget to true, so no need to set the size
# Setting up the Plane Widget which will be used for viewing the slice as well as a clipping plane
self.planeWidget = vtk.vtkPlaneWidget()
self.planeWidget.SetInteractor(self.renderInteractor)
self.planeWidget.SetResolution(
300) # this can be changed by the user from the Ui
self.planeWidget.SetPlaceFactor(1.15)
self.planeWidget.SetInput(self.reader.GetOutput())
self.planeWidget.PlaceWidget()
# Code for slicing and clipping the volume
self.plane = vtk.vtkPlane(
) # vtkPlane is used to add the current plane as a clipping plane in vtkVolumeMapper
self.planeWidget.GetPlane(
self.plane) # we get the current vtkPlane from the plane widget
self.plane2 = vtk.vtkPolyData(
) # vtkPolyData is used to get the slice and show it on the actor, tried this using the above vtkPlane, but didn't worked
self.planeWidget.GetPolyData(self.plane2)
self.planeWidget.SetRepresentationToOutline()
# probe filter computes point attributes (e.g., scalars, vectors, etc.) at specified point positions. If not added, renders just a white plane
self.probe = vtk.vtkProbeFilter()
self.probe.SetInput(self.plane2)
self.probe.SetSource(self.reader.GetOutput())
self.contourMapper = vtk.vtkPolyDataMapper()
self.contourMapper.SetInputConnection(self.probe.GetOutputPort())
self.contourMapper.SetScalarRange(
self.reader.GetOutput().GetScalarRange())
self.contourMapper.SetLookupTable(
self.colorFunc
) # this is like setting up the color map for the slice, we can directly pass the vtkColorFunction as a Lookup Table
self.contourActor = vtk.vtkActor()
self.contourActor.SetMapper(self.contourMapper)
self.contourActor.VisibilityOff()
self.renderer.AddActor(self.contourActor)
# Actually generate contour lines.
def BeginInteraction(obj, event):
obj.GetPolyData(self.plane2)
self.contourActor.VisibilityOn()
def ProbeData(obj, event):
obj.GetPolyData(self.plane2)
# Associate the widget with the interactor
self.planeWidget.SetInteractor(self.renderInteractor)
# Handle the events.
self.planeWidget.AddObserver("EnableEvent", BeginInteraction)
self.planeWidget.AddObserver("StartInteractionEvent", BeginInteraction)
self.planeWidget.AddObserver("InteractionEvent", ProbeData)
self.planeWidget.SetNormalToXAxis(True)
# For getting the outline(3D box) around the object
outline = vtk.vtkOutlineFilter()
outline.SetInput(self.reader.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(outlineMapper)
# We add outline actor to the renderer
self.renderer.AddActor(self.outlineActor)
# The Box widget
# The SetInteractor method is how 3D widgets are associated with the
# render window interactor. Internally, SetInteractor sets up a bunch
# of callbacks using the Command/Observer mechanism (AddObserver()).
self.boxWidget = vtk.vtkBoxWidget()
self.boxWidget.SetInteractor(self.renderInteractor)
self.boxWidget.SetPlaceFactor(1.0)
# When interaction starts, the requested frame rate is increased.
def StartInteraction(obj, event):
self.renderWin.SetDesiredUpdateRate(10)
# When interaction ends, the requested frame rate is decreased to
# normal levels. This causes a full resolution render to occur.
def EndInteraction(obj, event):
self.renderWin.SetDesiredUpdateRate(0.001)
# The implicit function vtkPlanes is used in conjunction with the
# volume ray cast mapper to limit which portion of the volume is
# volume rendered.
self.planes = vtk.vtkPlanes()
def ClipVolumeRender(obj, event):
obj.GetPlanes(self.planes)
self.volumeMapper.SetClippingPlanes(self.planes)
# Place the interactor initially. The output of the reader is used to
# place the box widget.
self.boxWidget.SetInput(self.reader.GetOutput())
self.boxWidget.PlaceWidget()
self.boxWidget.InsideOutOn()
self.boxWidget.AddObserver("StartInteractionEvent", StartInteraction)
self.boxWidget.AddObserver("InteractionEvent", ClipVolumeRender)
self.boxWidget.AddObserver("EndInteractionEvent", EndInteraction)
self.outlineProperty = self.boxWidget.GetOutlineProperty()
self.outlineProperty.SetRepresentationToWireframe()
self.outlineProperty.SetAmbient(1.0)
self.outlineProperty.SetAmbientColor(1, 1, 1)
self.outlineProperty.SetLineWidth(3)
self.selectedOutlineProperty = self.boxWidget.GetSelectedOutlineProperty(
)
self.selectedOutlineProperty.SetRepresentationToWireframe()
self.selectedOutlineProperty.SetAmbient(1.0)
self.selectedOutlineProperty.SetAmbientColor(1, 0, 0)
self.selectedOutlineProperty.SetLineWidth(3)
# Add the actors to the renderer,
self.boxWidget.Off()
# A simple function to be called when the user decides to quit the application.
def exitCheck(obj, event):
if obj.GetEventPending() != 0:
obj.SetAbortRender(1)
# Tell the application to use the function as an exit check.
self.renderWin.AddObserver("AbortCheckEvent", exitCheck)
self.alignedPlaneWidget = vtk.vtkImagePlaneWidget()
self.alignedPlaneWidget.DisplayTextOn()
self.alignedPlaneWidget.SetInput(self.reader.GetOutput())
self.alignedPlaneWidget.SetPlaneOrientationToZAxes()
self.alignedPlaneWidget.GetColorMap().SetLookupTable(self.colorFunc)
self.prop3 = self.alignedPlaneWidget.GetPlaneProperty()
self.prop3.SetColor(0, 0, 1)
self.alignedPlaneWidget.SetInteractor(self.renderInteractor)
#alignedPlaneWidget.On()
axes = vtk.vtkAxesActor()
self.widgetAxes = vtk.vtkOrientationMarkerWidget()
#widget->SetOutlineColor( 0.9300, 0.5700, 0.1300 );
self.widgetAxes.SetOrientationMarker(axes)
self.widgetAxes.SetInteractor(self.renderInteractor)
self.widgetAxes.SetViewport(0.0, 0.0, 0.3, 0.3)
#self.widgetA.SetEnabled( 1 )
#self.widgetA.InteractiveOff()
# XY plot in another renderer window
"""self.volumeMapperXY = vtk.vtkVolumeRayCastMapper()
self.volumeMapperXY.SetVolumeRayCastFunction(self.compositeFunction)
self.volumeMapperXY.SetInput(self.reader.GetOutput())
self.volumeXY = vtk.vtkVolume()
self.volumeXY.SetMapper(self.volumeMapper)
self.volumeXY.SetProperty(self.volumeProperty)
self.rendererXY = vtk.vtkRenderer()
self.renderWinXY = vtkWidgetXY.GetRenderWindow()
self.renderWinXY.AddRenderer(self.rendererXY)
#self.rendererXY.AddVolume(self.volumeXY)
self.rendererXY.SetBackground(0.321, 0.349, 0.435)
self.renderWinXY.SetSize(724,724)
self.xyActor = vtk.vtkActor2D()
self.xyMapper = vtk.vtkPolyDataMapper2D()
self.polyData = vtk.vtkPolyData()
self.alignedPlaneWidget.GetPolyData(self.polyData)
self.probe2 = vtk.vtkProbeFilter()
self.probe2.SetInput(self.polyData)
self.probe2.SetSource(self.reader.GetOutput())
self.xyMapper.SetInputConnection(self.probe2.GetOutputPort())
self.xyMapper.SetScalarRange(self.reader.GetOutput().GetScalarRange())
self.xyMapper.SetLookupTable(self.colorFunc)
self.xyActor.SetMapper(self.xyMapper)
self.rendererXY.AddActor(self.xyActor)
self.renderWinXY.Render()"""
"""# create object of vtkFFMPEGWriter so as to record a avi of all the interactions done with visualized obj
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(self.renderWin)
windowToImageFilter.SetInputBufferTypeToRGBA()
windowToImageFilter.ReadFrontBufferOff()
windowToImageFilter.Update()
self.recorder = vtk.vtkFFMPEGWriter()
self.recorder.SetQuality(1)
self.recorder.SetInput(windowToImageFilter.GetOutput())"""
# Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop.
self.renderInteractor.Initialize()
self.renderWin.Render()
self.renderer.ResetCamera()
self.renderInteractor.Start()
def __init__(self, data_dir, Mreader, Vreader):
# inv,inc,iniv,inxi,inxc Volume
# in9,in99,inim,ins Actors
planes = vtk.vtkPlane()
#planes.SetOrigin(0,-1,0)
#planes.SetNormal(1,0,0)
planeC = vtk.vtkPlaneCollection()
planeC.AddItem(planes)
######################################################
# Strip, Clip, Mapper, Actor
# Stripper for getting smooth poly outlines,
# gives circle and not random triangles
stripper = vtk.vtkStripper()
stripper.SetInputConnection(Mreader.GetOutputPort())
# Clipper for PLANE 1 Stripper 1
clipper = vtk.vtkClipClosedSurface()
clipper.SetInputConnection(stripper.GetOutputPort())
#clip.Update()
clipperOutline = vtk.vtkClipClosedSurface()
clipperOutline.SetInputConnection(stripper.GetOutputPort())
clipperOutline.SetClippingPlanes(planeC)
clipperOutline.GenerateFacesOff()
clipperOutline.GenerateOutlineOn()
innerNorms = vtk.vtkTriangleMeshPointNormals()
innerNorms.SetInputConnection(Mreader.GetOutputPort())
innerMapper = vtk.vtkOpenGLPolyDataMapper()
innerMapper.SetInputConnection(innerNorms.GetOutputPort())
innerActor = vtk.vtkActor()
innerActor.SetMapper(innerMapper)
clipMapper = vtk.vtkImageFlip()
clipMapper = vtk.vtkPolyDataMapper()
clipMapper.SetInputConnection(clipper.GetOutputPort())
clipActor = vtk.vtkActor()
clipActor.SetMapper(clipMapper)
clipActor.GetProperty().SetColor(1, 0.5, 0.5)
clipActor.GetProperty().SetOpacity(0.5)
clipActor.SetPosition(0.001, 0.001, 0.001)
clipperOutlineMapper = vtk.vtkPolyDataMapper()
clipperOutlineMapper.SetInputConnection(clipperOutline.GetOutputPort())
clipOutlineActor = vtk.vtkActor()
clipOutlineActor.SetMapper(clipperOutlineMapper)
clipOutlineActor.GetProperty().SetColor(0, 1, 0)
clipOutlineActor.SetPosition(0.001, 0.001, 0.001)
tfun = vtk.vtkPiecewiseFunction()
tfun.AddPoint(0, 0)
tfun.AddPoint(1600, 0.05)
tfun.AddPoint(2500, 0.15)
tfun.AddPoint(2400, 0.0)
tfun.AddPoint(2540, 0.97)
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(Vreader.GetOutputPort())
volumeMapper.SetBlendModeToComposite()
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetScalarOpacity(tfun)
volumeProperty.SetInterpolationTypeToLinear()
volumeProperty.ShadeOn()
newvol = vtk.vtkVolume()
newvol.SetMapper(volumeMapper)
newvol.SetProperty(volumeProperty)
#######################
planeWidget = vtk.vtkImagePlaneWidget()
planeWidget.RestrictPlaneToVolumeOn()
planeWidget.SetInputConnection(Mreader.GetOutputPort())
planeWidget.RestrictPlaneToVolumeOn()
planeWidget.GetResliceOutput()
rsx = planeWidget.GetResliceAxes()
#planeWidget.SetSliceIndex(52)
#planeWidget.SetOrigin(1,-1,-1)
planeWidget.SetResliceInterpolateToLinear()
planeWidget.PlaceWidget()
#planeWidget.SetInteractor(iren)
px = planeWidget.GetSlicePosition()
#Cut(px)
#clipActor.VisibilityOn()
def UpdateMesh(obj, event):
#global planes, clipActor
obj.GetNormal()
planes.SetNormal(obj.GetNormal())
planes.SetOrigin(obj.GetOrigin())
clipper.SetClippingPlanes(planeC)
clipActor.VisibilityOn()
planesS = vtk.vtkPlanes()
def ClipVolumeRender(obj, event):
#global planes, volumeMapper
planes.SetOrigin(obj.GetOrigin())
x2 = obj.GetOrigin()[0]
y2 = obj.GetOrigin()[1]
z2 = obj.GetOrigin()[2]
x3 = obj.GetPoint1()[0]
y3 = obj.GetPoint1()[1]
z3 = obj.GetPoint1()[2]
x1 = obj.GetPoint2()[0]
y1 = obj.GetPoint2()[1]
z1 = obj.GetPoint2()[2]
a1 = x2 - x1
b1 = y2 - y1
c1 = z2 - z1
a2 = x3 - x1
b2 = y3 - y1
c2 = z3 - z1
a = b1 * c2 - b2 * c1
b = a2 * c1 - a1 * c2
c = a1 * b2 - b1 * a2
d = (-a * x1 - b * y1 - c * z1)
#level1 = list([x,y,z,0,x,y,z,0,x,y,z,0,x,y,z,0,x,y,z,0,x,y,z,0])
level1 = list([
-a, -b, -c, -d, -a, -b, -c, -d, -a, -b, -c, -d, -a, -b, -c, -d,
-a, -b, -c, -d, -a, -b, -c, -d
])
print(a, b, c, d)
planesS.SetFrustumPlanes(level1)
#level2 = list([xMin,xMax, yMin,yMax,zMin,zMax])
#planesS.SetBounds(level2)
#planesS.SetNormals(obj.GetNormal())
#planesS.GetPlane(0,planes)
volumeMapper.SetClippingPlanes(planesS)
#print(planesS.GetPoints())
newvol.VisibilityOn()
ClipVolumeRender(planeWidget, "STR")
UpdateMesh(planeWidget, "STR")
#planeWidget.AddObserver("EndInteractionEvent", CutMesh)
#planeWidget.AddObserver("StartInteractionEvent", StartInteraction)
planeWidget.AddObserver("InteractionEvent", UpdateMesh)
#planeWidget.AddObserver("EndInteractionEvent", CutMesh)
planeWidget.AddObserver("InteractionEvent", ClipVolumeRender)
#planeWidget.AddObserver("EndInteractionEvent", EndInteraction)
self.planeWidget = planeWidget
#self.reader = reader
self.clipActor = clipActor
#ren1.AddActor(VActor)
self.newvol = newvol
self.clipOutlineActor = clipOutlineActor
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(self.onLoadClicked)
exitAct = QAction('&Exit', self)
exitAct.setShortcut('ALT+F4')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(exitAct)
self.vtk_widgets = [
Viewer2D(self.vtk_panel, 0),
Viewer2D(self.vtk_panel, 1),
Viewer2D(self.vtk_panel, 2)
]
# Make all views share the same cursor object
for i in range(3):
self.vtk_widgets[i].viewer.SetResliceCursor(
self.vtk_widgets[0].viewer.GetResliceCursor())
# Cursor representation (anti-alias)
for i in range(3):
for j in range(3):
prop = self.vtk_widgets[i].viewer.GetResliceCursorWidget(
).GetResliceCursorRepresentation().GetResliceCursorActor(
).GetCenterlineProperty(j)
renderLinesAsTubes(prop)
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
interactor = QVTKRenderWindowInteractor()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
# Create plane widgets
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
prop = pw.GetPlaneProperty()
renderLinesAsTubes(prop)
pw.SetPlaneProperty(prop)
prop = pw.GetSelectedPlaneProperty()
renderLinesAsTubes(prop)
pw.SetSelectedPlaneProperty(prop)
prop = pw.GetCursorProperty()
renderLinesAsTubes(prop)
pw.SetCursorProperty(prop)
pw.Modified()
self.planeWidget.append(pw)
for i in range(3):
color = [0.0, 0.0, 0.0]
color[i] = 1
# Set background for 2D views
for j in range(3):
color[j] = color[j] / 4.0
self.vtk_widgets[i].viewer.GetRenderer().SetBackground(color)
self.vtk_widgets[i].interactor.Disable()
self.establishCallbacks()
# Show widgets but hide non-existing data
for i in range(3):
self.vtk_widgets[i].show()
self.vtk_widgets[i].viewer.GetImageActor().SetVisibility(False)
# Layouts
horz_layout0 = QHBoxLayout()
vert_splitter = QSplitter(Qt.Vertical)
horz_splitter0 = QSplitter(Qt.Horizontal)
horz_splitter0.addWidget(self.vtk_widgets[0])
horz_splitter0.addWidget(self.vtk_widgets[1])
vert_splitter.addWidget(horz_splitter0)
horz_splitter1 = QSplitter(Qt.Horizontal)
horz_splitter1.addWidget(self.vtk_widgets[2])
horz_splitter1.addWidget(self.vtk_widgets[3])
vert_splitter.addWidget(horz_splitter1)
horz_layout0.addWidget(vert_splitter)
horz_layout0.setContentsMargins(0, 0, 0, 0)
self.vtk_panel.setLayout(horz_layout0)
self.checkBox.stateChanged.connect(self.SetResliceMode)
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(self.onLoadClicked)
exitAct = QAction('&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(exitAct)
self.vtk_widgets = [
Viewer2D(self.gridLayoutWidget, 0),
Viewer2D(self.gridLayoutWidget, 1),
Viewer2D(self.gridLayoutWidget, 2)
]
# Make all views share the same cursor object
for i in range(3):
self.vtk_widgets[i].viewer.SetResliceCursor(
self.vtk_widgets[0].viewer.GetResliceCursor())
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
interactor = QVTKRenderWindowInteractor()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
# Create plane widgets
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
# Set background for 2D views
for j in range(3):
color[j] = color[j] / 4.0
self.vtk_widgets[i].viewer.GetRenderer().SetBackground(color)
self.vtk_widgets[i].interactor.Disable()
self.planeWidget.append(pw)
self.establishCallbacks()
# Layouts - replace widgets
parent = self.gridLayoutWidget
parent.layout().replaceWidget(self.view1,
self.vtk_widgets[0].interactor)
parent.layout().replaceWidget(self.view2,
self.vtk_widgets[1].interactor)
parent.layout().replaceWidget(self.view3,
self.vtk_widgets[2].interactor)
parent.layout().replaceWidget(self.view4, self.vtk_widgets[3])
# Show widgets but hide non-existing data
for i in range(3):
self.vtk_widgets[i].show()
self.vtk_widgets[i].viewer.GetImageActor().SetVisibility(False)
self.resetButton.clicked.connect(self.ResetViews)
self.resliceModeCheckBox.stateChanged.connect(self.resliceMode)
self.thickModeCheckBox.stateChanged.connect(self.thickMode)
def _createIPW(self):
# we have to do this to get the correct log range
self._histogram.GetOutput().Update()
# this means we have newly valid input and should setup an ipw
self._ipw = vtk.vtkImagePlaneWidget()
self._histogram.GetOutput().Update()
self._ipw.SetInput(self._histogram.GetOutput())
self._ipw.SetInteractor(self._viewFrame.rwi)
# normal to the Z-axis
self._ipw.SetPlaneOrientation(2)
self._ipw.SetSliceIndex(0)
# setup specific lut
srange = self._histogram.GetOutput().GetScalarRange()
lut = vtk.vtkLookupTable()
lut.SetScaleToLog10()
lut.SetTableRange(srange)
lut.SetSaturationRange(1.0,1.0)
lut.SetValueRange(1.0, 1.0)
lut.SetHueRange(0.1, 1.0)
lut.Build()
self._ipw.SetUserControlledLookupTable(1)
self._ipw.SetLookupTable(lut)
self._ipw.SetDisplayText(1)
# if we use ContinousCursor, we get OffImage when zoomed
# on Linux (really irritating) but not on Windows. A VTK
# recompile might help, we'll see.
self._ipw.SetUseContinuousCursor(1)
# make sure the user can't twist the plane out of sight
self._ipw.SetMiddleButtonAction(0)
self._ipw.SetRightButtonAction(0)
# add an observer
self._ipw.AddObserver('StartInteractionEvent',
self._observerIPWInteraction)
self._ipw.AddObserver('InteractionEvent',
self._observerIPWInteraction)
self._ipw.AddObserver('EndInteractionEvent',
self._observerIPWInteraction)
self._ipw.On()
self._axes = vtk.vtkCubeAxesActor2D()
self._axes.SetFlyModeToOuterEdges()
# NOBODY will ever know why we have to switch off the Y axis when
# we actually want the Z-axis to go away.
self._axes.YAxisVisibilityOff()
self._axes.SetBounds(self._ipw.GetResliceOutput().GetBounds())
self._renderer.AddActor(self._axes)
self._axes.SetCamera(self._renderer.GetActiveCamera())
self._axes.PickableOff()
if 0:
# now add a scalarbar
self._scalarBarWidget = vtk.vtkScalarBarWidget()
self._scalarBarWidget.SetInteractor(self._viewFrame.rwi)
self._scalarBarWidget.GetScalarBarActor().SetTitle('Frequency')
self._scalarBarWidget.GetScalarBarActor().SetLookupTable(
lut)
# and activate
self._scalarBarWidget.On()
self._resetCamera()
self._render()
def __init__(self, file_list,spacing_list,feature_type,irad = 1.2, h_th=-200,
glyph_type='sphere', glyph_scale_factor=1,use_field_data=True, opacity_list=[],
color_list=[], lung=[]):
assert feature_type == "ridge_line" or feature_type == "valley_line" \
or feature_type == "ridge_surface" or feature_type == "valley_surface" \
or feature_type == "vessel" or feature_type == "airway" \
or feature_type == "fissure", "Invalid feature type"
if feature_type == "airway":
feature_type = "valley_line"
elif feature_type == "vessel":
feature_type = "ridge_line"
elif feature_type == "fissure":
feature_type = "ridge_surface"
self.mapper_list = list()
self.actor_list = list()
self.glyph_list = list()
self.glyph_type = glyph_type
self.file_list = file_list
self.spacing_list = spacing_list
self.opacity_list = opacity_list
self.irad = irad
self.h_th = h_th
self.color_list = color_list
self.lung = lung
self.use_field_data = use_field_data
self.feature_type = feature_type
self.normal_map=dict()
self.normal_map['ridge_line'] = "hevec0"
self.normal_map['valley_line'] = "hevec2"
self.normal_map['ridge_surface'] = "hevec2"
self.normal_map['valley_surface'] = "hevec0"
self.strength_map=dict()
self.strength_map['ridge_line'] = "h1"
self.strength_map['valley_line'] = "h1"
self.strength_map['ridge_surface'] = "h2"
self.strength_map['valley_surface'] = "h0"
if feature_type == 'ridge_line' or feature_type == 'valley_line':
self.height = irad
self.radius = 0.5
elif feature_type == 'ridge_surface' or feature_type == 'valley_surface':
self.height = 0.5
self.radius = irad
self.min_rad = 0.5
self.max_rad = 6
self.glyph_scale_factor = glyph_scale_factor
self.capture_prefix = ""
self.capture_count = 1
self.image_count = 1
# VTK Objects
self.ren = vtk.vtkOpenGLRenderer()
self.renWin = vtk.vtkRenderWindow()
self.iren = vtk.vtkRenderWindowInteractor()
# Volume rendering objects
self.volumeActor = vtk.vtkVolume()
self.volumeMapper = vtk.vtkVolumeRayCastMapper()
#self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
# Variables for the interaction
self.volume_loaded = False
self.volume_added_to_renderer = False
self.volume_size = [0,0,0]
self.particles_loaded = False
self.particles_added_to_renderer = False
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.lastPlaneWidget = self.planeWidgetX
self.lastPlaneWidgetIndex = 0
self.planeWidgetLayer = [0,0,0]
self.boxWidgetVolume = vtk.vtkBoxWidget()
self.boxWidgetParticles = vtk.vtkBoxWidget()
self.planesParticles = vtk.vtkPlanes()
self.planesParticles.SetBounds(-10000,10000,-10000,10000,-10000,10000); # For some reason planes needs initializaiton
self.planesVolume = vtk.vtkPlanes()
self.planesVolume.SetBounds(-10000,10000,-10000,10000,-10000,10000); # For some reason planes needs initializaiton
new_data.DeepCopy(temp_data)
#outline
outline = vtk.vtkOutlineFilter()
outline.SetInputData(new_data)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
#Picker
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
#PlaneWidget
planeWidgetX = vtk.vtkImagePlaneWidget()
planeWidgetX.DisplayTextOn()
planeWidgetX.SetInputData(new_data)
planeWidgetX.SetPlaneOrientationToXAxes()
planeWidgetX.SetSliceIndex(100)
planeWidgetX.SetPicker(picker)
planeWidgetX.SetKeyPressActivationValue("x")
prop1 = planeWidgetX.GetPlaneProperty()
prop1.SetColor(1, 0, 0)
planeWidgetY = vtk.vtkImagePlaneWidget()
planeWidgetY.DisplayTextOn()
planeWidgetY.SetInputData(new_data)
planeWidgetY.SetPlaneOrientationToYAxes()
planeWidgetY.SetSliceIndex(100)
planeWidgetY.SetPicker(picker)
def setup(self):
self.setupUi(self)
loadAct = QAction('&Open', self)
loadAct.setShortcut('Ctrl+O')
loadAct.setStatusTip('Load data')
loadAct.triggered.connect(lambda: self.onLoadClicked(0))
surfAct = QAction('&Open Surface', self)
surfAct.setShortcut('Ctrl+S')
surfAct.setStatusTip('Surf data')
surfAct.triggered.connect(lambda: self.onLoadClicked(1))
exitAct = QAction('&Exit', self)
exitAct.setShortcut('ALT+F4')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(self.close)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(loadAct)
fileMenu.addAction(surfAct)
fileMenu.addAction(exitAct)
self.vtk_widgets = [
Viewer2D(self.vtk_panel, 0),
Viewer2D(self.vtk_panel, 1),
Viewer2D(self.vtk_panel, 2)
]
# Make all views share the same cursor object
for i in range(3):
self.vtk_widgets[i].viewer.SetResliceCursor(
self.vtk_widgets[0].viewer.GetResliceCursor())
# Cursor representation (anti-alias)
for i in range(3):
for j in range(3):
prop = self.vtk_widgets[i].viewer.GetResliceCursorWidget(
).GetResliceCursorRepresentation().GetResliceCursorActor(
).GetCenterlineProperty(j)
renderLinesAsTubes(prop)
# Make 3D viewer
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
ipwProp = vtk.vtkProperty()
ren = vtk.vtkRenderer()
interactor = QVTKRenderWindowInteractor()
# Gradient background
ren.SetBackground(245.0 / 255.0, 245.0 / 255.0, 245.0 / 255.0)
ren.SetBackground2(170.0 / 255.0, 170.0 / 255.0, 170.0 / 255.0)
ren.GradientBackgroundOn()
interactor.GetRenderWindow().AddRenderer(ren)
self.vtk_widgets.append(interactor)
# Create plane widgets
self.planeWidget = []
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(ipwProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(ren)
prop = pw.GetPlaneProperty()
renderLinesAsTubes(prop)
pw.SetPlaneProperty(prop)
prop = pw.GetSelectedPlaneProperty()
renderLinesAsTubes(prop)
pw.SetSelectedPlaneProperty(prop)
prop = pw.GetCursorProperty()
renderLinesAsTubes(prop)
pw.SetCursorProperty(prop)
prop = pw.GetTextProperty()
prop.SetColor(black)
pw.Modified()
# Set background for 2D views
for j in range(3):
color[j] = color[j] / 4.0
self.vtk_widgets[i].viewer.GetRenderer().SetBackground(color)
self.vtk_widgets[i].interactor.Disable()
self.planeWidget.append(pw)
# Annotation
cornerAnnotation = vtk.vtkCornerAnnotation()
cornerAnnotation.SetLinearFontScaleFactor(2)
cornerAnnotation.SetNonlinearFontScaleFactor(1)
cornerAnnotation.SetMaximumFontSize(20)
cornerAnnotation.SetText(vtk.vtkCornerAnnotation.UpperLeft, '3D')
cornerAnnotation.GetTextProperty().SetColor(1, 1, 1)
cornerAnnotation.SetWindowLevel(
self.vtk_widgets[0].viewer.GetWindowLevel())
ren.AddViewProp(cornerAnnotation)
# Create cube, Right Anterior Superior
colors = vtk.vtkNamedColors()
xyzLabels = ['X', 'Y', 'Z']
scale = (1.5, 1.5, 1.5)
axes2 = MakeCubeActor(scale, xyzLabels, colors)
self.om2 = vtk.vtkOrientationMarkerWidget()
self.om2.SetOrientationMarker(axes2)
# Position lower right in the viewport.
self.om2.SetInteractor(self.vtk_widgets[3])
self.om2.SetViewport(0.75, 0, 1.0, 0.25)
self.establishCallbacks()
# Show widgets but hide non-existing data
for i in range(3):
self.vtk_widgets[i].show()
self.vtk_widgets[i].viewer.GetImageActor().SetVisibility(False)
# Layouts
horz_layout0 = QHBoxLayout()
vert_splitter = QSplitter(Qt.Vertical)
horz_splitter0 = QSplitter(Qt.Horizontal)
horz_splitter0.addWidget(self.vtk_widgets[0])
horz_splitter0.addWidget(self.vtk_widgets[1])
vert_splitter.addWidget(horz_splitter0)
horz_splitter1 = QSplitter(Qt.Horizontal)
horz_splitter1.addWidget(self.vtk_widgets[2])
horz_splitter1.addWidget(self.vtk_widgets[3])
vert_splitter.addWidget(horz_splitter1)
horz_layout0.addWidget(vert_splitter)
horz_layout0.setContentsMargins(0, 0, 0, 0)
self.vtk_panel.setLayout(horz_layout0)
vert_layout = QVBoxLayout()
horz_layout1 = QHBoxLayout()
self.btnSagittal = QPushButton("S")
self.btnSagittal.setCheckable(True)
self.btnSagittal.setChecked(True)
horz_layout1.addWidget(self.btnSagittal)
self.btnCoronal = QPushButton("C")
self.btnCoronal.setCheckable(True)
self.btnCoronal.setChecked(True)
horz_layout1.addWidget(self.btnCoronal)
self.btnAxial = QPushButton("A")
self.btnAxial.setCheckable(True)
self.btnAxial.setChecked(True)
self.btnSagittal.clicked.connect(self.togglePlanes)
self.btnCoronal.clicked.connect(self.togglePlanes)
self.btnAxial.clicked.connect(self.togglePlanes)
horz_layout1.addWidget(self.btnAxial)
verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
vert_layout.addItem(verticalSpacer)
vert_layout.addItem(horz_layout1)
self.frame.setLayout(vert_layout)
