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.distanceWidget = vtk.vtkDistanceWidget()
self.obsTag = self.distanceWidget.AddObserver("EndInteractionEvent", self.onPlacePoint)
self.representation = vtkbxd.vtkDistanceRepresentationScaled2D()
self.representation.SetScaleX(1.0)
self.representation.SetScaleZ(1.0)
self.distanceWidget.SetRepresentation(self.representation)
self.renderer = self.parent.getRenderer()
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
self.distanceWidget.SetInteractor(iactor)
self.picker = vtk.vtkCellPicker()
self.currentPlane = None
#self.picker.SetTolerance(0.05)
#self.updateRendering()
self.filterDesc = "Measure distance in 3D view"
def key_press(self, interactor, event):
key = interactor.GetKeySym()
#XXX this is annoying in dwm (and probably elsewhere)
#if self.pickerName is None:
#error_msg('You must select the pick segment in the Picker tab')
#return
def checkPickerName():
if self.pickerName is None:
error_msg('You must select the pick segment in the Picker tab')
return False
return True
if key.lower()=='q': #hehehe
gtk.main_quit()
if key.lower()=='i':
if not checkPickerName():
return
print "Inserting Marker"
x,y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
o = self.paramd[self.pickerName]
picker.AddPickList(o.isoActor)
picker.SetTolerance(0.005)
picker.Pick(x, y, 0, self.sr.renderer)
points = picker.GetPickedPositions()
numPoints = points.GetNumberOfPoints()
if numPoints<1: return
pnt = points.GetPoint(0)
marker = Marker(xyz=pnt,
rgb=EventHandler().get_default_color())
EventHandler().add_marker(marker)
elif key.lower()=='x':
if not checkPickerName():
return
x,y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
for o in self.paramd.values():
picker.AddPickList(o.isoActor)
picker.SetTolerance(0.01)
picker.Pick(x, y, 0, self.sr.renderer)
cellId = picker.GetCellId()
if cellId==-1:
pass
else:
o = self.paramd.values()[0]
o.remove.RemoveCell(cellId)
interactor.Render()
elif key.lower()=='e':
if not checkPickerName():
return
o = self.paramd.values()[0]
pw = o.planeWidget
if pw.GetEnabled():
pw.EnabledOff()
else:
pw.EnabledOn()
def key_press(self, interactor, event):
key = interactor.GetKeySym()
#XXX this is annoying in dwm (and probably elsewhere)
#if self.pickerName is None:
#error_msg('You must select the pick segment in the Picker tab')
#return
def checkPickerName():
if self.pickerName is None:
error_msg('You must select the pick segment in the Picker tab')
return False
return True
if key.lower() == 'q': #hehehe
gtk.main_quit()
if key.lower() == 'i':
if not checkPickerName():
return
print "Inserting Marker"
x, y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
o = self.paramd[self.pickerName]
picker.AddPickList(o.isoActor)
picker.SetTolerance(0.005)
picker.Pick(x, y, 0, self.sr.renderer)
points = picker.GetPickedPositions()
numPoints = points.GetNumberOfPoints()
if numPoints < 1: return
pnt = points.GetPoint(0)
marker = Marker(xyz=pnt, rgb=EventHandler().get_default_color())
EventHandler().add_marker(marker)
elif key.lower() == 'x':
if not checkPickerName():
return
x, y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
for o in self.paramd.values():
picker.AddPickList(o.isoActor)
picker.SetTolerance(0.01)
picker.Pick(x, y, 0, self.sr.renderer)
cellId = picker.GetCellId()
if cellId == -1:
pass
else:
o = self.paramd.values()[0]
o.remove.RemoveCell(cellId)
interactor.Render()
elif key.lower() == 'e':
if not checkPickerName():
return
o = self.paramd.values()[0]
pw = o.planeWidget
if pw.GetEnabled():
pw.EnabledOff()
else:
pw.EnabledOn()
def key_press(self, interactor, event):
if shared.debug: print "key press event in SurfRenderWindow"
key = interactor.GetKeySym()
sas = self.surface_actors
def checkPickerId():
if not self.picker_id:
error_msg('Cannot insert marker. Choose surface first.')
return False
return True
if key.lower()=='q': #hehehe
gtk.main_quit()
if key.lower()=='i':
if not checkPickerId():
return
if shared.debug: print "Inserting Marker"
x,y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
actor = self.__get_surface_actor(self.picker_id)
if actor==None: return
picker.AddPickList(actor)
picker.SetTolerance(0.005)
picker.Pick(x, y, 0, self.renderer)
points = picker.GetPickedPositions()
numPoints = points.GetNumberOfPoints()
if numPoints<1: return
pnt = points.GetPoint(0)
marker = Marker(xyz=pnt,
rgb=EventHandler().get_default_color(),
radius=shared.ratio*shared.marker_size)
EventHandler().add_marker(marker)
elif key.lower()=='x':
#if not checkPickerIdx():
# return
x,y = interactor.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.PickFromListOn()
for actor in sas:
picker.AddPickList(actor)
picker.SetTolerance(0.01)
picker.Pick(x, y, 0, self.renderer)
cellId = picker.GetCellId()
if cellId==-1:
pass
else:
o = self.paramd.values()[0]
o.remove.RemoveCell(cellId)
interactor.Render()
def __init__(self, interactor, key_callback, mouse_callback):
self.interactor = interactor
self.picker = vtk.vtkCellPicker()
self.key_callback = key_callback
self.mouse_callback = mouse_callback
self.AddObserver("KeyPressEvent", self.key_pressed)
self.AddObserver("MouseMoveEvent", self.mouse_moved)
def _update_picking_callback(plotter,
on_mouse_move,
on_button_press,
on_button_release,
on_pick):
interactor = plotter.iren
interactor.AddObserver(
vtk.vtkCommand.RenderEvent,
on_mouse_move
)
interactor.AddObserver(
vtk.vtkCommand.LeftButtonPressEvent,
on_button_press
)
interactor.AddObserver(
vtk.vtkCommand.EndInteractionEvent,
on_button_release
)
picker = vtk.vtkCellPicker()
picker.AddObserver(
vtk.vtkCommand.EndPickEvent,
on_pick
)
picker.SetVolumeOpacityIsovalue(0.)
plotter.picker = picker
def create_cell_picker(self):
"""creates the vtk picker objects"""
self.cell_picker = vtk.vtkCellPicker()
self.node_picker = vtk.vtkPointPicker()
self.area_picker = vtk.vtkAreaPicker() # vtkRenderedAreaPicker?
self.rubber_band_style = vtk.vtkInteractorStyleRubberBandPick()
#vtk.vtkInteractorStyleRubberBand2D
#vtk.vtkInteractorStyleRubberBand3D
#vtk.vtkInteractorStyleRubberBandZoom
#vtk.vtkInteractorStyleAreaSelectHover
#vtk.vtkInteractorStyleDrawPolygon
#vtk.vtkAngleWidget
#vtk.vtkAngleRepresentation2D
#vtk.vtkAngleRepresentation3D
#vtk.vtkAnnotation
#vtk.vtkArrowSource
#vtk.vtkGlyph2D
#vtk.vtkGlyph3D
#vtk.vtkHedgeHog
#vtk.vtkLegendBoxActor
#vtk.vtkLegendScaleActor
#vtk.vtkLabelPlacer
self.cell_picker.SetTolerance(0.001)
self.node_picker.SetTolerance(0.001)
def SpaceCallback(self,obj):
picker = vtk.vtkCellPicker()
picker.SetTolerance(1E-4 * self.Surface.GetLength())
eventPosition = self.vmtkRenderer.RenderWindowInteractor.GetEventPosition()
#eventPosition = obj.GetEventPosition()
result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer)
if result == 0:
return
pickPosition = picker.GetPickPosition()
pickedCellPointIds = self.Surface.GetCell(picker.GetCellId()).GetPointIds()
minDistance = 1E10
pickedSeedId = -1
for i in range(pickedCellPointIds.GetNumberOfIds()):
distance = vtk.vtkMath.Distance2BetweenPoints(pickPosition,self.Surface.GetPoint(pickedCellPointIds.GetId(i)))
if distance < minDistance:
minDistance = distance
pickedSeedId = pickedCellPointIds.GetId(i)
if pickedSeedId == -1:
pickedSeedId = pickedCellPointIds.GetId(0)
if (self.InteractionMode==0):
self.SeedIds.InsertNextId(pickedSeedId)
point = self.Surface.GetPoint(pickedSeedId)
self.SeedPoints.GetPoints().InsertNextPoint(point)
self.SeedPoints.Modified()
else:
point = self.Surface.GetPoint(pickedSeedId)
self.ExamineSpheres.GetPoints().InsertNextPoint(point)
length = 0.
array = self.ExamineSurface.GetPointData().GetArray(self.DijkstraDistanceToPointsArrayName)
if array:
length = array.GetComponent(pickedSeedId,0)
self.ExamineSpheres.GetPointData().GetScalars().InsertNextValue(length)
self.ExamineSpheres.Modified()
self.vmtkRenderer.RenderWindow.Render()
def PickCallback(self, obj):
picker = vtk.vtkCellPicker()
picker.SetTolerance(1E-4 * self._Surface.GetLength())
eventPosition = self.vmtkRenderer.RenderWindowInteractor.GetEventPosition(
)
result = picker.Pick(float(eventPosition[0]), float(eventPosition[1]),
0.0, self.vmtkRenderer.Renderer)
if result == 0:
return
pickPosition = picker.GetPickPosition()
pickedCellPointIds = self._Surface.GetCell(
picker.GetCellId()).GetPointIds()
minDistance = 1E10
pickedSeedId = -1
for i in range(pickedCellPointIds.GetNumberOfIds()):
distance = vtk.vtkMath.Distance2BetweenPoints(
pickPosition,
self._Surface.GetPoint(pickedCellPointIds.GetId(i)))
if distance < minDistance:
minDistance = distance
pickedSeedId = pickedCellPointIds.GetId(i)
if pickedSeedId == -1:
pickedSeedId = pickedCellPointIds.GetId(0)
self.PickedSeedIds.InsertNextId(pickedSeedId)
point = self._Surface.GetPoint(pickedSeedId)
self.PickedSeeds.GetPoints().InsertNextPoint(point)
self.PickedSeeds.Modified()
self.vmtkRenderer.RenderWindow.Render()
def KeyPressed(self,obj,event):
key = obj.GetKeySym()
if key == 'u':
self.InitializeSeeds()
self.PickedSeeds.Modified()
self.vmtkRenderer.RenderWindow.Render()
return
elif key == 'space':
picker = vtk.vtkCellPicker()
picker.SetTolerance(1E-4 * self._Surface.GetLength())
eventPosition = obj.GetEventPosition()
result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer)
if result == 0:
return
pickPosition = picker.GetPickPosition()
pickedCellPointIds = self._Surface.GetCell(picker.GetCellId()).GetPointIds()
minDistance = 1E10
pickedSeedId = -1
for i in range(pickedCellPointIds.GetNumberOfIds()):
distance = vtk.vtkMath.Distance2BetweenPoints(pickPosition,self._Surface.GetPoint(pickedCellPointIds.GetId(i)))
if distance < minDistance:
minDistance = distance
pickedSeedId = pickedCellPointIds.GetId(i)
if pickedSeedId == -1:
pickedSeedId = pickedCellPointIds.GetId(0)
self.PickedSeedIds.InsertNextId(pickedSeedId)
point = self._Surface.GetPoint(pickedSeedId)
self.PickedSeeds.GetPoints().InsertNextPoint(point)
self.PickedSeeds.Modified()
self.vmtkRenderer.RenderWindow.Render()
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 do_trace(self, obj, e):
global im_view, trace_mode, cur_picked_point, trace_mode, traced_lines, color_red, color_green, traced_tree
cur_slice = im_view.GetSlice()
click_pos = self.GetInteractor().GetEventPosition()
if trace_mode == True and choose_mode == False:
if cur_picked_point == [] and len(traced_lines) != 0:
print "Must Choose a Point to Start!"
else:
trace_picker = vtk.vtkCellPicker()
trace_picker.Pick(click_pos[0], click_pos[1], cur_slice, im_view.GetRenderer())
picked_pos = trace_picker.GetPickPosition()
traced_point = np.require(picked_pos, dtype=np.uint16)
self.save2lines(traced_point)
self.ShowPoint(traced_point, color_red)
if cur_picked_point != []:
self.ShowLine(cur_picked_point.tolist(), traced_point.tolist())
self.changeColor(traced_point, color_green, color_red)
cur_picked_point = traced_point
if choose_mode == True and trace_mode == False:
if traced_tree.size() == 0:
print "No Point to Choose, Please Trace First!"
else:
choose_picker = vtk.vtkPropPicker()
choose_picker.Pick(click_pos[0], click_pos[1], cur_slice, im_view.GetRenderer())
if choose_picker.GetActor() != None:
choosen_point = choose_picker.GetActor().GetMapper().GetInput().GetCenter()
choosen_point = np.array(choosen_point, dtype=np.uint16)
self.changeColor(choosen_point, color_green, color_red)
cur_picked_point = choosen_point
else:
print "Please Choose a Point"
def __init__(self, *args, **kwargs):
VtkRenderArea.__init__(self, *args, **kwargs)
self._CurrentRenderer = None
self._CurrentCamera = None
self._CurrentZoom = 1.0
self._CurrentLight = None
self._ViewportCenterX = 0
self._ViewportCenterY = 0
self._Picker = vtk.vtkCellPicker()
self._PickedAssembly = None
self._PickedProperty = vtk.vtkProperty()
self._PickedProperty.SetColor(1, 0, 0)
self._PrePickedProperty = None
self._OldFocus = None
# need this to be able to handle key_press events.
self.set_flags(gtk.CAN_FOCUS)
# these record the previous mouse position
self._LastX = 0
self._LastY = 0
self.connect('button_press_event', self.OnButtonDown)
self.connect('button_release_event', self.OnButtonUp)
self.connect('motion_notify_event', self.OnMouseMove)
self.connect('key_press_event', self.OnKeyPress)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.POINTER_MOTION_HINT_MASK)
def __init__(self, imageData=None):
MarkerWindowInteractor.__init__(self)
if 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.textActors = {}
self.boxes = {}
self.set_image_data(imageData)
self.Render()
self.vtk_translation = zeros(3, 'd')
self.vtk_rotation = zeros(3, 'd')
def PickCallback(self,obj):
picker = vtk.vtkCellPicker()
picker.SetTolerance(1E-4 * self.Surface.GetLength())
eventPosition = self.vmtkRenderer.RenderWindowInteractor.GetEventPosition()
#eventPosition = obj.GetEventPosition()
result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer)
if result == 0:
return
pickPosition = picker.GetPickPosition()
if (self.InteractionMode==0):
self.CurrentSphereId = self.Spheres.GetPoints().InsertNextPoint(pickPosition)
self.Spheres.GetPointData().GetScalars().InsertNextValue(self.Surface.GetLength()*0.01)
self.Spheres.Modified()
self.PlaceSphere()
self.SphereWidget.On()
else:
pickedCellPointIds = self.Surface.GetCell(picker.GetCellId()).GetPointIds()
minDistance = 1E10
pickedPointId = -1
for i in range(pickedCellPointIds.GetNumberOfIds()):
distance = vtk.vtkMath.Distance2BetweenPoints(pickPosition,self.Surface.GetPoint(pickedCellPointIds.GetId(i)))
if distance < minDistance:
minDistance = distance
pickedPointId = pickedCellPointIds.GetId(i)
if pickedPointId == -1:
pickedPointId = pickedCellPointIds.GetId(0)
point = self.Surface.GetPoint(pickedPointId)
self.ExamineSpheres.GetPoints().InsertNextPoint(point)
length = 0.
array = self.ExamineSurface.GetPointData().GetArray(self.DistanceToSpheresArrayName)
if (array):
length = array.GetComponent(pickedPointId,0)
self.ExamineSpheres.GetPointData().GetScalars().InsertNextValue(length)
self.ExamineSpheres.Modified()
self.vmtkRenderer.RenderWindow.Render()
def __init__(self, *args, **kwargs):
VtkRenderArea.__init__(self, *args, **kwargs)
self._CurrentRenderer = None
self._CurrentCamera = None
self._CurrentZoom = 1.0
self._CurrentLight = None
self._ViewportCenterX = 0
self._ViewportCenterY = 0
self._Picker = vtk.vtkCellPicker()
self._PickedAssembly = None
self._PickedProperty = vtk.vtkProperty()
self._PickedProperty.SetColor(1, 0, 0)
self._PrePickedProperty = None
self._OldFocus = None
# need this to be able to handle key_press events.
self.set_flags(gtk.CAN_FOCUS)
# these record the previous mouse position
self._LastX = 0
self._LastY = 0
self.connect('button_press_event', self.OnButtonDown)
self.connect('button_release_event', self.OnButtonUp)
self.connect('motion_notify_event', self.OnMouseMove)
self.connect('key_press_event', self.OnKeyPress)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.KEY_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
def select_event(self, obj, event):
'''Process a select event.
'''
print("Select ...")
clickPos = self.GetInteractor().GetEventPosition()
picker = vtk.vtkCellPicker()
picker.Pick(clickPos[0], clickPos[1], 0, self.renderer)
# Get selecected geometry.
self.picked_actor = picker.GetActor()
if self.picked_actor == None:
print("No actor selected")
#self.OnLeftButtonDown()
return
graphics = self.graphics
for node_id, node in self.graphics.node_actors.items():
if self.picked_actor == node[0]:
pos = [node[1].x, node[1].y, node[1].z]
print("Selected node ID: {0:d} position: {1:s}".format(node_id, str(pos)))
self.picked_actor.GetProperty().SetColor(1.0, 1.0, 0.0)
if self.last_picked_node_actor != None:
self.last_picked_node_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
self.last_picked_node_actor = self.picked_actor
for segment_id, segment in self.graphics.segment_actors.items():
if self.picked_actor == segment[0]:
print("Selected segment ID: {0:s}".format(segment_id))
self.picked_actor.GetProperty().SetColor(1.0, 1.0, 0.0)
if self.last_picked_segment_actor != None:
self.last_picked_segment_actor.GetProperty().SetColor(1.0, 0.0, 0.0)
self.last_picked_segment_actor = self.picked_actor
def add_picker(self):
# Create a cell picker.
picker = vtk.vtkCellPicker()
# Create a Python function to create the text for the text mapper used
# to display the results of picking.
source = vtk.vtkVectorText()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
follower = vtk.vtkFollower()
follower.SetMapper(mapper)
follower.GetProperty().SetColor((0, 0, 0))
follower.SetScale(0.2)
self.ren.AddActor(follower)
follower.SetCamera(self.ren.GetActiveCamera())
follower.VisibilityOff()
def annotate_pick(obj, event):
if picker.GetCellId() < 0:
follower.VisibilityOff()
else:
pick_pos = picker.GetPickPosition()
mapper = picker.GetMapper()
if mapper in self.mapper_map:
site = self.mapper_map[mapper]
output = [site.species_string, "Frac. coords: " +
" ".join(["{:.4f}".format(c)
for c in
site.frac_coords])]
source.SetText("\n".join(output))
follower.SetPosition(pick_pos)
follower.VisibilityOn()
picker.AddObserver("EndPickEvent", annotate_pick)
self.picker = picker
self.iren.SetPicker(picker)
def add_picker_fixed(self):
# Create a cell picker.
picker = vtk.vtkCellPicker()
# Create a Python function to create the text for the text mapper used
# to display the results of picking.
def annotate_pick(obj, event):
if picker.GetCellId() < 0 and not self.show_help:
self.helptxt_actor.VisibilityOff()
else:
mapper = picker.GetMapper()
if mapper in self.mapper_map:
output = []
for site in self.mapper_map[mapper]:
row = ["{} - ".format(site.species_string),
", ".join(["{:.3f}".format(c)
for c in site.frac_coords]),
"[" + ", ".join(["{:.3f}".format(c)
for c in site.coords]) +
"]"]
output.append("".join(row))
self.helptxt_mapper.SetInput("\n".join(output))
self.helptxt_actor.SetPosition(10, 10)
self.helptxt_actor.VisibilityOn()
self.show_help = False
self.picker = picker
picker.AddObserver("EndPickEvent", annotate_pick)
self.iren.SetPicker(picker)
def __init__(self, slice3dVWRThingy, sliceGrid):
self.slice3dVWR = slice3dVWRThingy
self._grid = sliceGrid
self._sliceDirectionsDict = {}
# this same picker is used on all new IPWS of all sliceDirections
self.ipwPicker = vtk.vtkCellPicker()
self.currentCursor = None
# configure the grid from scratch
self._initialiseGrid()
self._initUI()
# bind all events
self._bindEvents()
# fill out our drop-down menu
self._disableMenuItems = self._appendGridCommandsToMenu(
self.slice3dVWR.controlFrame.slicesMenu,
self.slice3dVWR.controlFrame, disable=True)
self.overlayMode = 'greenOpacityRange'
self.fusionAlpha = 0.4
# this will make all ipw slice polydata available at the output
self.ipwAppendPolyData = vtk.vtkAppendPolyData()
# this append filter will make all slice data available at the output
self.ipwAppendFilter = vtk.vtkAppendFilter()
# create the first slice
self._createSlice('Axial')
def SetupPlaneWidgets(self):
picker = vtk.vtkCellPicker()
picker.SetTolerance(0.005)
pwTextureProp = vtk.vtkProperty()
for i in range(3):
pw = vtk.vtkImagePlaneWidget()
pw.SetInteractor(self.interactor)
pw.SetPicker(picker)
pw.RestrictPlaneToVolumeOn()
color = [0.0, 0.0, 0.0]
color[i] = 1
pw.GetPlaneProperty().SetColor(color)
pw.SetTexturePlaneProperty(pwTextureProp)
pw.TextureInterpolateOn()
pw.SetResliceInterpolateToLinear()
pw.DisplayTextOn()
pw.SetDefaultRenderer(self.renderer)
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()
self.planeWidgets.append(pw)
def leftButtonDown(self, *arg):
inter1 = self.GetInteractor()
click_pos = inter1.GetEventPosition()
s = imageViewer.GetSlice()
# print imageViewer.GetSize()
# print imageViewer.GetImageActor().GetBounds()
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0] + 1, click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1] + 1, s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0] - 1, click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1] - 1, s, 0, 255.0)
# image_import.Modified()
# image_import.Update()
# imageViewer.SetInput(image_import.GetOutput())
# imageViewer.Render()
picker = vtk.vtkCellPicker()
picker.Pick(click_pos[0], click_pos[1], s, imageViewer.GetRenderer())
pos = picker.GetPickPosition()
print pos
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(pos[0], pos[1], pos[2])
sphereSource.SetRadius(1)
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
sphereActor.GetProperty().SetColor(255.0, 0.0, 0.0)
imageViewer.GetRenderer().AddActor(sphereActor)
imageViewer.Render()
def init_vtk_view(self):
# 在之前创建的view_widget上添加vtk控件
self.vtk_vertical_layout = QVBoxLayout(self.view_widget)
self.vtk_widget = QVTKRenderWindowInteractor(self.view_widget)
self.vtk_vertical_layout.addWidget(self.vtk_widget)
# 1.创建RenderWindow窗口
self.render_window = self.vtk_widget.GetRenderWindow()
# 2.创建render
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(1.0, 1.0, 1.0) # 设置页面底部颜色值
self.renderer.SetBackground2(0.1, 0.2, 0.4) # 设置页面顶部颜色值
self.renderer.SetGradientBackground(1) # 开启渐变色背景设置
self.render_window.AddRenderer(self.renderer)
self.render_window.Render()
# 3.设置交互方式
self.iren = self.render_window.GetInteractor() # 获取交互器
self.style = vtk.vtkInteractorStyleTrackballCamera(
) # 交互器样式的一种，该样式下，用户是通过控制相机对物体作旋转、放大、缩小等操作
# self.style = MyInteractor(self)
self.style.SetDefaultRenderer(self.renderer)
self.iren.SetInteractorStyle(self.style)
# 拾取器
cellPicker = vtk.vtkCellPicker()
self.iren.SetPicker(cellPicker)
# 4.添加坐标轴(加self,血的教训）
axesActor = vtk.vtkAxesActor()
self.axes_widget = vtk.vtkOrientationMarkerWidget()
self.axes_widget.SetOrientationMarker(axesActor)
self.axes_widget.SetInteractor(self.iren)
self.axes_widget.EnabledOn()
self.axes_widget.InteractiveOff() # 坐标系是否可移动
# 5.添加Actor
self.original_actor = vtk.vtkActor()
def __init__(self, parent, visualizer, **kws):
"""
Method: __init__(parent)
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
VisualizationModule.__init__(self, parent, visualizer, **kws)
#self.name = "Arbitrary Slices"
self.on = 0
self.renew = 1
self.mapper = vtk.vtkPolyDataMapper()
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.5)
self.planes = []
self.renderer = self.parent.getRenderer()
self.renderer.AddActor(self.outlineActor)
self.ctf = None
self.origin = None
self.spacing = None
self.extent = None
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 add_picker(self):
# Create a cell picker.
picker = vtk.vtkCellPicker()
# Create a Python function to create the text for the text mapper used
# to display the results of picking.
source = vtk.vtkVectorText()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
follower = vtk.vtkFollower()
follower.SetMapper(mapper)
follower.GetProperty().SetColor((0, 0, 0))
follower.SetScale(0.2)
self.ren.AddActor(follower)
follower.SetCamera(self.ren.GetActiveCamera())
follower.VisibilityOff()
def annotate_pick(obj, event):
if picker.GetCellId() < 0:
follower.VisibilityOff()
else:
pick_pos = picker.GetPickPosition()
mapper = picker.GetMapper()
if mapper in self.mapper_map:
site = self.mapper_map[mapper]
output = [
site.species_string, "Frac. coords: " + " ".join(
["{:.4f}".format(c) for c in site.frac_coords])
]
source.SetText("\n".join(output))
follower.SetPosition(pick_pos)
follower.VisibilityOn()
picker.AddObserver("EndPickEvent", annotate_pick)
self.picker = picker
self.iren.SetPicker(picker)
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 add_picker_fixed(self):
# Create a cell picker.
picker = vtk.vtkCellPicker()
# Create a Python function to create the text for the text mapper used
# to display the results of picking.
def annotate_pick(obj, event):
if picker.GetCellId() < 0 and not self.show_help:
self.helptxt_actor.VisibilityOff()
else:
mapper = picker.GetMapper()
if mapper in self.mapper_map:
output = []
for site in self.mapper_map[mapper]:
row = [
"{} - ".format(site.species_string), ", ".join([
"{:.3f}".format(c) for c in site.frac_coords
]), "[" + ", ".join(
["{:.3f}".format(c)
for c in site.coords]) + "]"
]
output.append("".join(row))
self.helptxt_mapper.SetInput("\n".join(output))
self.helptxt_actor.SetPosition(10, 10)
self.helptxt_actor.VisibilityOn()
self.show_help = False
self.picker = picker
picker.AddObserver("EndPickEvent", annotate_pick)
self.iren.SetPicker(picker)
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,
vertices=True,
faces=True,
actors=True,
world_coords=True):
""" Picking Manager helps with picking 3D objects
Parameters
-----------
vertices : bool
If True allows to pick vertex indices.
faces : bool
If True allows to pick face indices.
actors : bool
If True allows to pick actor indices.
world_coords : bool
If True allows to pick xyz position in world coordinates.
"""
self.pickers = {}
if vertices:
self.pickers['vertices'] = vtk.vtkPointPicker()
if faces:
self.pickers['faces'] = vtk.vtkCellPicker()
if actors:
self.pickers['actors'] = vtk.vtkPropPicker()
if world_coords:
self.pickers['world_coords'] = vtk.vtkWorldPointPicker()
def leftButtonPressEvent(self, obj, event):
"""
Process left mouse button press.
"""
clickPos = self.GetInteractor().GetEventPosition()
picker = vtk.vtkCellPicker()
picker.Pick(clickPos[0], clickPos[1], 0, self.renderer)
# Get selecected geometry.
self.picked_actor = picker.GetActor()
if self.picked_actor == None:
self.OnLeftButtonDown()
return
graphics = self.graphics
# Identify the selected segment.
for seg_name, seg_actor in self.graphics.segment_actors.items():
if self.picked_actor == seg_actor:
graphics.logger.info(" ")
graphics.logger.info("Selected segment %s" % seg_name)
graphics.picked_segment = seg_name
#__for seg_name,seg_actor in self.graphics.segment_actors.items()
if self.last_picked_actor:
self.last_picked_actor.GetProperty().SetColor(
*GeometryColors.SEGMENT)
self.picked_actor.GetProperty().SetColor(
*GeometryColors.SEGMENT_HIGHLIGHT)
self.last_picked_actor = self.picked_actor
self.OnLeftButtonDown()
return
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, parent=None, fix_camera=True,
background=None, size=None):
'''
fix_camera : more sensible default
'''
if parent is not None:
self.renWin = parent.GetRenderWindow()
self.iren = self.renWin.GetInteractor()
else:
self.renWin = vtk.vtkRenderWindow()
if size is None:
self.renWin.SetSize(800, 600)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.ren = vtk.vtkRenderer()
if background == 'white':
self.ren.SetBackground(1, 1, 1)
self.renWin.AddRenderer(self.ren)
if fix_camera:
camera = vtk.vtkInteractorStyleTrackballCamera()
camera.SetCurrentRenderer(self.ren)
self.iren.SetInteractorStyle(camera)
self.picker = vtk.vtkCellPicker()
self.iren.SetPicker(self.picker)
self.picker.AddObserver("EndPickEvent", self.handle_pick)
def pickLine(self, obj, e): # print obj == self!!!!!!!!!!!!!!!!!!!!
global poly1, ren, iren, renWin, cell_scalars, edit_mode
clickPos = self.GetInteractor().GetEventPosition()
print e
if edit_mode is True:
print "hhhh"
print self.GetInteractor().GetLastEventPosition()
print self.GetInteractor().GetEventPosition()
picker = vtk.vtkCellPicker()
picker.SetTolerance(1 / 80.0)
picker.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker.GetCellId()
if cell_scalars.GetTuple(picker.GetCellId(
))[0] == 0.0 and cell_scalars.GetTuple(
picker.GetCellId())[1] == 255.0 and cell_scalars.GetTuple(
picker.GetCellId())[2] == 255.0:
poly1.GetCellData().GetScalars().SetTupleValue(
picker.GetCellId(), [255, 0, 255])
else:
poly1.GetCellData().GetScalars().SetTupleValue(
picker.GetCellId(), [0, 255, 255])
poly1.GetCellData().Modified()
poly1.GetCellData().Update()
else:
print "ssss"
self.OnLeftButtonDown()
def leftButtonDown(self, *arg):
inter1 = self.GetInteractor()
click_pos = inter1.GetEventPosition()
s = imageViewer.GetSlice()
# print imageViewer.GetSize()
# print imageViewer.GetImageActor().GetBounds()
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0] + 1, click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1] + 1, s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0] - 1, click_pos[1], s, 0, 255.0)
# image_data.SetScalarComponentFromFloat(click_pos[0], click_pos[1] - 1, s, 0, 255.0)
# image_import.Modified()
# image_import.Update()
# imageViewer.SetInput(image_import.GetOutput())
# imageViewer.Render()
picker = vtk.vtkCellPicker()
picker.Pick(click_pos[0], click_pos[1], s, imageViewer.GetRenderer())
pos = picker.GetPickPosition()
print pos
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(pos[0], pos[1], pos[2])
sphereSource.SetRadius(1)
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
sphereActor.GetProperty().SetColor(255.0, 0.0, 0.0)
imageViewer.GetRenderer().AddActor(sphereActor)
imageViewer.Render()
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, 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 onSliceClicked(self, istyle, event):
'''Slice click callback'''
clickX, clickY = istyle.GetInteractor().GetEventPosition()
picker = vtk.vtkCellPicker()
if picker.Pick(clickX, clickY, 0, self.sliceRenderer):
point = picker.GetPickedPositions().GetPoint(0)
# set z coord to be current slice location
self.imageVoxelSelected.emit(point[0], point[1], self.slicePosition)
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 _update_picking_callback(self, on_mouse_move, on_button_press,
on_button_release, on_pick):
add_obs = self.plotter.iren.add_observer
add_obs(vtk.vtkCommand.RenderEvent, on_mouse_move)
add_obs(vtk.vtkCommand.LeftButtonPressEvent, on_button_press)
add_obs(vtk.vtkCommand.EndInteractionEvent, on_button_release)
self.plotter.picker = vtk.vtkCellPicker()
self.plotter.picker.AddObserver(vtk.vtkCommand.EndPickEvent, on_pick)
self.plotter.picker.SetVolumeOpacityIsovalue(0.)
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):
# FIXME: the idea is not using Slice from here...!
#self.slice_ = slc.Slice()
self.picker = vtk.vtkCellPicker() # define position where user clicked
self.mouse_pressed = 0 # define if operation will executed run or not
self.style = const.OP_ADD # define brush operation .OP_DEL, .OP_THRESH
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, parent, ident):
self.ren = None # The Renderer
self.rwi = None # The reneder Windows
self.action = "" # No action
# create wx.Frame and wxVTKRenderWindowInteractor to put in it
wx.Frame.__init__(self,
parent,
ident,
"DRE wxVTK demo",
size=(400, 400))
# create a menuBar
menuBar = wx.MenuBar()
# add a File Menu
menuFile = wx.Menu()
itemQuit = menuFile.Append(-1, "&Quit", "Quit application")
self.Bind(wx.EVT_MENU, self.OnQuit, itemQuit)
menuBar.Append(menuFile, "&File")
# add an Action Menu
# menuAction = wx.Menu()
# itemSelect = menuAction.AppendCheckItem(-1, "&Select\tS", "Select an object")
# self.Bind(wx.EVT_MENU, self.OnSelect, itemSelect)
# menuBar.Append(menuAction, "&File")
self.SetMenuBar(menuBar)
self.statusBar = self.CreateStatusBar()
self.statusBar.SetFieldsCount(2)
self.statusBar.SetStatusWidths([-4, -1])
# the render is a 3D Scene
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.2, 0.5, 0.7)
# create the world
self.CreateWorld(self.ren)
#make sure the RWI sizes to fill the frame
self.rwi = wxVTKRenderWindow(self, -1)
self.rwi.GetRenderWindow().AddRenderer(self.ren)
# trap mouse events
self.rwi.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.rwi.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.rwi.Bind(wx.EVT_LEFT_DCLICK, self.OnSelect)
self.rwi.Bind(wx.EVT_MOTION, self.OnMotion)
# store the Picker
self.picker = vtk.vtkCellPicker()
self.pickedActor = None
self.pickedProperty = None
self.selectProperty = vtk.vtkProperty()
self.selectProperty.SetColor(1, 0, 0)
def MouseMove(obj, ev):
if pickedPoint == -1: return
pos = obj.GetEventPosition()
picker = vtk.vtkCellPicker()
picker.Pick(pos[0], pos[1], 0, renderer)
landmark.SetPoint(pickedPoint, picker.GetPickPosition())
landmark.Modified()
def _observerPointWidgetInteraction(self, pw, evt_name):
# we have to find pw in our list
pwidgets = map(lambda i: i['pointWidget'], self._pointsList)
if pw in pwidgets:
idx = pwidgets.index(pw)
# toggle the selection for this point in our list
self._grid.SelectRow(idx)
# if this is lockToSurface, lock it! (and we can only lock
# to something if there're some pickable objects as reported
# by the tdObjects class)
pp = self.slice3dVWR._tdObjects.getPickableProps()
if self._pointsList[idx]['lockToSurface'] and pp:
tdren = self.slice3dVWR._threedRenderer
# convert the actual pointwidget position back to
# display coord
tdren.SetWorldPoint(pw.GetPosition() + (1,))
tdren.WorldToDisplay()
ex,ey,ez = tdren.GetDisplayPoint()
# we make use of a CellPicker (for the same reasons we
# use it during the initial placement of a surface point)
picker = vtk.vtkCellPicker()
# this is quite important
picker.SetTolerance(0.005)
# tell the picker which props it's allowed to pick from
for p in pp:
picker.AddPickList(p)
picker.PickFromListOn()
# and go!
picker.Pick(ex, ey, 0.0, tdren)
if picker.GetActor():
# correct the pointWidget's position so it sticks to
# the surface
pw.SetPosition(picker.GetPickPosition())
# get its position and transfer it to the sphere actor that
# we use
pos = pw.GetPosition()
self._pointsList[idx]['sphereActor'].SetAttachmentPoint(pos)
val, discrete = self.slice3dVWR.getValueAtPositionInInputData(pos)
if val == None:
discrete = (0, 0, 0)
val = 0
# the cursor is a tuple with discrete position and value
self._pointsList[idx]['discrete'] = tuple(discrete)
# 'world' is the world coordinates
self._pointsList[idx]['world'] = tuple(pos)
# and the value
self._pointsList[idx]['value'] = val
self._syncGridRowToSelPoints(idx)
def plot(self, struct):
# creates self. data1, legend, filename, fieldname, dim, has_field, tracker, revision
if not self.call_config(struct):
return
# creates self.src
if not self.call_src():
return
self.add_outline_2(self.src)
if self.has_field:
self.add_labels_b_1()
if self.data1.get('fielddomain') == 'cell':
self.cellcenters = vtk.vtkCellCenters()
self.cellcenters.SetInputConnection(self.src.GetOutputPort())
self.add_labels_b_2([self.cellcenters])
else:
self.add_labels_b_2([self.src])
# aqui para que apareza de ultimo
# so con campo?
self.add_search_1(self.search_callback,
self.search_callback_coords)
# wireframe
self.wireM = vtk.vtkDataSetMapper()
self.wireM.SetInputConnection(self.src.GetOutputPort())
self.wireM.ScalarVisibilityOff()
self.wireA = vtk.vtkActor()
self.wireA.SetMapper(self.wireM)
self.wireA.GetProperty().SetRepresentationToWireframe()
self.wireA.GetProperty().SetColor(Plot.mesh_color)
self.add_sw_2(self.wireA)
self.rens[0].AddActor(self.wireA)
self.set_iren()
#MouseMoveEvent
self.iren.AddObserver("LeftButtonPressEvent", self.ButtonEvent)
#self.iren.AddObserver("LeftButtonReleaseEvent", self.ButtonEvent2)
if self.data1.get('fielddomain') == 'cell':
self.picker = vtk.vtkCellPicker()
else:
self.picker = vtk.vtkPointPicker()
self.picker.AddObserver("EndPickEvent", self.EndPick)
self.iren.SetPicker(self.picker)
self.copy_params(struct)
self.done = True
def _observerPointWidgetInteraction(self, pw, evt_name):
# we have to find pw in our list
pwidgets = map(lambda i: i['pointWidget'], self._pointsList)
if pw in pwidgets:
idx = pwidgets.index(pw)
# toggle the selection for this point in our list
self._grid.SelectRow(idx)
# if this is lockToSurface, lock it! (and we can only lock
# to something if there're some pickable objects as reported
# by the tdObjects class)
pp = self.slice3dVWR._tdObjects.getPickableProps()
if self._pointsList[idx]['lockToSurface'] and pp:
tdren = self.slice3dVWR._threedRenderer
# convert the actual pointwidget position back to
# display coord
tdren.SetWorldPoint(pw.GetPosition() + (1, ))
tdren.WorldToDisplay()
ex, ey, ez = tdren.GetDisplayPoint()
# we make use of a CellPicker (for the same reasons we
# use it during the initial placement of a surface point)
picker = vtk.vtkCellPicker()
# this is quite important
picker.SetTolerance(0.005)
# tell the picker which props it's allowed to pick from
for p in pp:
picker.AddPickList(p)
picker.PickFromListOn()
# and go!
picker.Pick(ex, ey, 0.0, tdren)
if picker.GetActor():
# correct the pointWidget's position so it sticks to
# the surface
pw.SetPosition(picker.GetPickPosition())
# get its position and transfer it to the sphere actor that
# we use
pos = pw.GetPosition()
self._pointsList[idx]['sphereActor'].SetAttachmentPoint(pos)
val, discrete = self.slice3dVWR.getValueAtPositionInInputData(pos)
if val == None:
discrete = (0, 0, 0)
val = 0
# the cursor is a tuple with discrete position and value
self._pointsList[idx]['discrete'] = tuple(discrete)
# 'world' is the world coordinates
self._pointsList[idx]['world'] = tuple(pos)
# and the value
self._pointsList[idx]['value'] = val
self._syncGridRowToSelPoints(idx)
def build_panel(self):
self._iren = MyRenderWindowInteractor(self, wx.ID_ANY, size=self.GetSize())
self._iren.SetPosition((0,0))
# define interaction style
self._iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera() # change interaction style
self._iren.Enable(1)
# create renderer
self._renderer = vtk.vtkRenderer()
self._iren.GetRenderWindow().AddRenderer(self._renderer)
# cam stuff
self.camera=vtk.vtkCamera() # create camera
self._renderer.SetActiveCamera(self.camera) # associate camera to renderer
self.camera.SetFocalPoint(0, 0, 0)
self.camera.SetPosition(0, 0, 20)
self.__pickerObserverId = None
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self._iren.AddObserver("TimerEvent", self.on_timer)
self._iren.RemoveObservers("CharEvent")
self._iren.AddObserver("CharEvent", self.on_keyboard_input)
self._iren.AddObserver("LeftButtonPressEvent", self.emulate_focus)
pub.subscribe(self.check_switch_consistancy, ('Switch'))
self._iren.Bind(wx.EVT_CONTEXT_MENU, self.on_show_popup_menu)
self._mgr.AddPane(self._iren, aui.AuiPaneInfo().Dock().Center().CaptionVisible(False).CloseButton(False))
self._mgr.Update()
self._first = True
self._timerCounter = 0
self._timerInterval = 5
self._animationLoop = False
self._trajectoryLoaded = False
self._currentFrame = 0
self._maxLaps = 100
self.display_bbox = False
self.bbox = None
self._surface = None
self._iso = None
# Atoms picked from mouse or selection box.
self.__pickedAtoms = set()
self.SetFocusIgnoringChildren()
def pickLine(self, obj, e):
global cube1, ren, iren, cubeActor
clickPos = self.GetInteractor().GetEventPosition()
print clickPos
# print obj == self
picker = vtk.vtkCellPicker()
picker.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker.GetCellId()
picker2 = vtk.vtkPropPicker()
picker2.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker2.GetActor() == cubeActor
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 pickLine(self, obj, e):
global cube1, ren, iren, cubeActor
clickPos = self.GetInteractor().GetEventPosition()
print clickPos
# print obj == self
picker = vtk.vtkCellPicker()
picker.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker.GetCellId()
picker2 = vtk.vtkPropPicker()
picker2.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker2.GetActor() == cubeActor
def pickLine(self, obj, e):
global line1, ren, iren, actor1
clickPos = self.GetInteractor().GetEventPosition()
print clickPos
# print obj == self
picker = vtk.vtkCellPicker()
print picker.GetTolerance()
picker.SetTolerance(1 / 80.0)
picker.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
print picker.GetCellId()
picker2 = vtk.vtkPropPicker()
picker2.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
def __init__(self, parent, ident):
self.ren = None # The Renderer
self.rwi = None # The reneder Windows
self.action = "" # No action
# create wx.Frame and wxVTKRenderWindowInteractor to put in it
wx.Frame.__init__(self, parent, ident, "DRE wxVTK demo", size=(400,400))
# create a menuBar
menuBar = wx.MenuBar()
# add a File Menu
menuFile = wx.Menu()
itemQuit = menuFile.Append(-1, "&Quit", "Quit application")
self.Bind(wx.EVT_MENU, self.OnQuit, itemQuit)
menuBar.Append(menuFile, "&File")
# add an Action Menu
# menuAction = wx.Menu()
# itemSelect = menuAction.AppendCheckItem(-1, "&Select\tS", "Select an object")
# self.Bind(wx.EVT_MENU, self.OnSelect, itemSelect)
# menuBar.Append(menuAction, "&File")
self.SetMenuBar(menuBar)
self.statusBar = self.CreateStatusBar()
self.statusBar.SetFieldsCount(2)
self.statusBar.SetStatusWidths([-4, -1])
# the render is a 3D Scene
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.2, 0.5, 0.7)
# create the world
self.CreateWorld(self.ren)
#make sure the RWI sizes to fill the frame
self.rwi = wxVTKRenderWindow(self, -1)
self.rwi.GetRenderWindow().AddRenderer(self.ren)
# trap mouse events
self.rwi.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.rwi.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.rwi.Bind(wx.EVT_LEFT_DCLICK, self.OnSelect)
self.rwi.Bind(wx.EVT_MOTION, self.OnMotion)
# store the Picker
self.picker = vtk.vtkCellPicker()
self.pickedActor = None
self.pickedProperty = None
self.selectProperty = vtk.vtkProperty()
self.selectProperty.SetColor(1,0,0)
def mousePressEvent(self, e):
if e.type() == QEvent.MouseButtonDblClick:
logger.debug( "double clicked" )
#self.picker.SetTolerance(0.05)
picker = vtkCellPicker()
picker.SetTolerance(0.05)
res = picker.Pick(e.pos().x(), e.pos().y(), 0, self.renderer)
if res > 0:
c = picker.GetPickPosition()
logger.debug( " picked at coordinate = {}".format( c ) )
self.emit(SIGNAL("objectPicked"), c[0:3])
else:
QVTKWidget2.mousePressEvent(self, e)
def addPicker(self):
self.textMapper = vtk.vtkTextMapper()
tprop = self.textMapper.GetTextProperty()
tprop.SetFontFamilyToArial()
tprop.SetFontSize(10)
tprop.BoldOn()
tprop.ShadowOn()
tprop.SetColor(1, 0, 0)
self.textActor.VisibilityOff()
self.textActor.SetMapper(self.textMapper)
self.picker = vtk.vtkCellPicker()
def annotatePick(object, event):
print("pick")
if self.picker.GetCellId() < 0:
self.textActor.VisibilityOff()
else:
selPt = self.picker.GetSelectionPoint()
pickPos = self.picker.GetPickPosition()
pickPosInt = (round(pickPos[0]), round(pickPos[1]),round(pickPos[2]))
pickPosIntStr = str(pickPosInt)
pickPosIntQStr = Qt.QString(pickPosIntStr)
i = self.materialControl.currentIndex()
j = self.controlTypeTab[i].currentIndex()
if j == 0:
if self.firstPlanePt[i].isChecked():
self.firstPlanePtValueRecord[i] = pickPos
self.firstPlanePtValue[i].setText(pickPosIntQStr)
if self.secondPlanePt[i].isChecked():
self.secondPlanePtValueRecord[i] = pickPos
self.secondPlanePtValue[i].setText(pickPosIntQStr)
if self.thirdPlanePt[i].isChecked():
self.thirdPlanePtValueRecord[i] = pickPos
self.thirdPlanePtValue[i].setText(pickPosIntQStr)
else:
if self.controlPt[i].isChecked():
self.controlPtValueRecord[i] = pickPos
self.controlPtValue[i].setText(pickPosIntQStr)
pickValue = self.data_matrix_red[round(pickPos[2]),round(pickPos[1]),round(pickPos[0])]
self.textMapper.SetInput("(%.3i, %.3i, %.3i)"%pickPosInt)
print pickValue
self.textActor.SetPosition(selPt[:2])
self.textActor.VisibilityOn()
# Now at the end of the pick event call the above function.
self.picker.AddObserver("EndPickEvent", annotatePick)
self.iren.SetPicker(self.picker)
# Add the actors to the renderer, set the background and size
self.ren.AddActor2D(self.textActor)
def plot_planes(array_in, log=False, cmap=None):
"""Plot two interactive planes cutting the provided volume."""
array_in = _numpy.float64(array_in)
renderer = _vtk.vtkRenderer()
render_window = _vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
interactor = _vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(render_window)
interactor.SetInteractorStyle(_vtk.vtkInteractorStyleRubberBandPick())
if cmap == None:
import matplotlib as _matplotlib
cmap = _matplotlib.rcParams["image.cmap"]
lut = get_lookup_table(max(0., array_in.min()), array_in.max(), log=log, colorscale=cmap)
picker = _vtk.vtkCellPicker()
picker.SetTolerance(0.005)
image_data = array_to_image_data(array_in)
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
plane_1 = setup_plane()
plane_1.SetPlaneOrientationToXAxes()
plane_1.SetSliceIndex(array_in.shape[0]//2)
plane_1.SetEnabled(1)
plane_2 = setup_plane()
plane_2.SetPlaneOrientationToYAxes()
plane_2.SetSliceIndex(array_in.shape[1]//2)
plane_2.SetEnabled(1)
renderer.SetBackground(0., 0., 0.)
render_window.SetSize(800, 800)
interactor.Initialize()
render_window.Render()
interactor.Start()
