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)