Python vtk.vtkCellPicker函数代码示例

    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, 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 __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, *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 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 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 __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 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 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, 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 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, 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)