Python vtk.vtkPlanes函数代码示例

 def __init__(self,viewer, selection_color):
     self.viewer = viewer
     self.selection_color = selection_color
     outline = vtk.vtkOutlineFilter()
     if vtk.vtkVersion.GetVTKMajorVersion()<6:
         outline.SetInput(self.viewer._polydata)
     else:
         outline.SetInputData(self.viewer._polydata)
                 
     outlineMapper = vtk.vtkPolyDataMapper()
     outlineMapper.SetInputConnection(outline.GetOutputPort())
     self.box=vtk.vtkActor()
     self.box.SetMapper( outlineMapper )
     self.box.GetProperty().SetColor(1,1,1)
     self.box.PickableOff()
     
     self.SetProp3D(self.box)
     self.planes=vtk.vtkPlanes()
     self.SetInteractor(viewer.iren)
     if vtk.vtkVersion.GetVTKMajorVersion()<6:
         self.SetInput(self.viewer._polydata)
     else:
         self.SetInputData(self.viewer._polydata)
         
     self.SetPlaceFactor(1)
     self.PlaceWidget()
     self.InsideOutOn()
     self.SetRotationEnabled(0)
     self.GetPlanes(self.planes)
     self.AddObserver("EndInteractionEvent",self.on_select_atoms)

    def box_select_points(self, start_pos, end_pos):
        aspect = self.model_viewer.viewer.renderer.GetAspect()
        frustum_planes = np.zeros(24)
        self.model_viewer.viewer.renderer.GetActiveCamera().GetFrustumPlanes(aspect[0] / aspect[1], frustum_planes)
        min_pos = np.fmin(start_pos, end_pos)
        max_pos = np.fmax(start_pos, end_pos) + 1

        # Shift frustum planes inwards to match the box selection
        y_world_size = 2.0 * self.model_viewer.viewer.renderer.GetActiveCamera().GetParallelScale()
        window_size = self.model_viewer.viewer.renderer.GetSize()
        pixel_to_world_scale = y_world_size / window_size[1]
        frustum_planes[3] -= pixel_to_world_scale * min_pos[0]
        frustum_planes[7] -= pixel_to_world_scale * (window_size[0] - max_pos[0])
        frustum_planes[11] -= pixel_to_world_scale * min_pos[1]
        frustum_planes[15] -= pixel_to_world_scale * (window_size[1] - max_pos[1])

        # For visualization, it's better to set near and far planes from depth of filtered data
        planes = vtk.vtkPlanes()
        planes.SetFrustumPlanes(frustum_planes)
        self.model_viewer.point_cloud_troupe.set_filtering_frustum(planes)
        filtered_ids = self.model_viewer.point_cloud_troupe.get_filtered_ids()
        if len(filtered_ids) > 0:
            dists = self.model_viewer.cached_points[filtered_ids, :].dot(frustum_planes[16:19])
            min_dist = np.min(dists)
            max_dist = np.max(dists)
            range = max_dist - min_dist
            range = max(range, 0.01)
            frustum_planes[19] = -min_dist + 0.1 * range
            frustum_planes[23] = max_dist + 0.1 * range
            self.set_roibox(frustum_planes)
        else:
            self.reset_roibox()
        # Potential workaround for http://www.vtk.org/Bug/view.php?id=7823
        # self.model_viewer.viewer.renderer.ResetCamera()
        self.model_viewer.change_mode(ViewModes.EDIT_BONES)

    def voiWidgetInteractionCallback(self, o, e):
        planes = vtk.vtkPlanes()
        o.GetPlanes(planes)
        bounds =  planes.GetPoints().GetBounds()

        # first set bounds
        self.controlFrame.voiBoundsText.SetValue(
            "(%.2f %.2f %.2f %.2f %.2f %.2f) mm" %
            bounds)

        input_data = self.getPrimaryInput()
        if input_data:
            ispacing = input_data.GetSpacing()
            iorigin = input_data.GetOrigin()
            # calculate discrete coords
            bounds = planes.GetPoints().GetBounds()
            voi = 6 * [0]
            # excuse the for loop :)
            for i in range(6):
                voi[i] = int(round((bounds[i] - iorigin[i / 2]) / ispacing[i / 2]))

            # store the VOI (this is a shallow copy)
            self._currentVOI = voi
            # display the discrete extent
            self.controlFrame.voiExtentText.SetValue(
                "(%d %d %d %d %d %d)" % tuple(voi))

    def Execute(self):

        if self.Surface == None:
            self.PrintError('Error: no Surface.')

        if self.WidgetType == "box":
            self.ClipFunction = vtk.vtkPlanes()
        elif self.WidgetType == "sphere":
            self.ClipFunction = vtk.vtkSphere()

        self.Clipper = vtk.vtkClipPolyData()
        self.Clipper.SetInput(self.Surface)
        self.Clipper.SetClipFunction(self.ClipFunction)
        self.Clipper.GenerateClippedOutputOn()
        self.Clipper.InsideOutOn()
        
        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(self.Surface)
        mapper.ScalarVisibilityOff()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        if self.WidgetType == "box":
            self.ClipWidget = vtk.vtkBoxWidget()
            self.ClipWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
            self.ClipWidget.GetFaceProperty().SetOpacity(0.25)
        elif self.WidgetType == "sphere":
            self.ClipWidget = vtk.vtkSphereWidget()
            self.ClipWidget.GetSphereProperty().SetColor(0.6,0.6,0.2)
            self.ClipWidget.GetSphereProperty().SetOpacity(0.25)
            self.ClipWidget.GetSelectedSphereProperty().SetColor(0.6,0.0,0.0)
            self.ClipWidget.GetSelectedSphereProperty().SetOpacity(0.75)
            self.ClipWidget.SetRepresentationToSurface()
            self.ClipWidget.SetPhiResolution(20)
            self.ClipWidget.SetThetaResolution(20)

        self.ClipWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
        self.Display()

        self.Transform = vtk.vtkTransform()
        self.ClipWidget.GetTransform(self.Transform)

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()

        if self.CleanOutput == 1:
            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.Surface)
            cleaner.Update()
            self.Surface = cleaner.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()

 def SelectPolygons(self, widget, event_string):
     # As can be seen the callback takes two arguments.  The first being the object that generates the event 
     # and the second argument the event name (which is a string).        
     self.planes = vtk.vtkPlanes()
     self.boxWidget.GetPlanes(self.planes)
     self.boundsPlane_presel = self.planes.GetPoints().GetBounds()
     
     return

 def executeClip( self, caller=None, event=None ):
     planes = vtk.vtkPlanes(); np = 6
     self.clipper.GetPlanes(planes)
     if not self.cropRegion: self.cropRegion = [0.0]*np
     for ip in range( np ):
         plane = planes.GetPlane( ip )
         o = plane.GetOrigin()
         self.cropRegion[ip] = o[ ip/2 ]
     self.cropVolume() 

 def createContent( self ):
     input =  self.module.inputModule.getOutput()  
     self.boxWidget = vtk.vtkBoxWidget()
     self.boxWidget.SetRotationEnabled(0)
     self.boxWidget.SetPlaceFactor(1.0)
     self.boxWidget.SetInput( input )
     self.planes = vtk.vtkPlanes()
     self.boxWidget.AddObserver("StartInteractionEvent", self.startConfiguration )
     self.boxWidget.AddObserver("InteractionEvent",      self.updateConfiguration )
     self.boxWidget.AddObserver("EndInteractionEvent",   self.endConfiguration ) 

    def __init__( self, parent, imode_callback, rmode_callback, ppos_callback, ao, **kwargs ):
        # initialize Panel
        if 'id' not in kwargs:
            kwargs['id'] = wx.ID_ANY
        wx.Panel.__init__( self, parent, **kwargs )

        self.setInteractionMode = imode_callback
        self.setInteractionMode(True)
        
        self.recordingMode = False
        self.setRecordingMode = rmode_callback
        self.setRecordingMode(False)
        
        self.setPickerPos = ppos_callback
        
        self.ao = ao
        self.aa = False
        self.firstRender = True

        self.vtkWidget = wxVTKRenderWindowInteractor(self, wx.ID_ANY)
        self.iren = self.vtkWidget._Iren
        self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
        
        self.renderer = vtk.vtkRenderer()
        self.renderer.SetBackground(0,0,0)
        self.imageLayer = {}
        self.CISID = -1  # Current Image Set ID
        self.imageLayer[self.CISID] = IBCRenderer(self.renderer, self.iren.Render)
        self.bacteriaLayer = BacteriaLayer(self.renderer, self.iren.Render)
        
        self.viewCamActive = True
        
        # for interactive clipping
        self.planes = vtk.vtkPlanes()
        
        self.ellipsoid = None
        self.ellipsoidTextActor = None
        
        # 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.iren)
        self.boxWidget.SetPlaceFactor(1.0)

        # init vtk window
        self.vtkWidget.Enable(1)
        self.vtkWidget.AddObserver("ExitEvent", lambda o,e,f=parent: f.Close())
        self.vtkWidget.GetRenderWindow().AddRenderer(self.renderer)
        
        # Bind VTK events
        self.iren.AddObserver("KeyPressEvent", self.OnKeyDown)
        
        self.Sizer = wx.BoxSizer()
        self.Sizer.Add(self.vtkWidget, 1, wx.EXPAND)

 def set_region_of_interest(self, planes_vector):
     if planes_vector is None:
         self.planes_troupe.set_visible(False)
         if self.point_cloud_troupe is not None:
             self.point_cloud_troupe.set_filtering_frustum(None)
     else:
         planes = vtk.vtkPlanes()
         planes.SetFrustumPlanes(planes_vector)
         if self.point_cloud_troupe is not None:
             self.point_cloud_troupe.set_filtering_frustum(planes)
         self.planes_troupe.set_planes(planes)
         self.planes_troupe.set_visible(True)

	def resetClippingBox(self):
		"""
		Resets position and shape of the clipping box.
		"""
		# Reset the planes by setting identity transform
		transform = vtkTransform()
		self.clippingBox.SetTransform(transform)

		# Make sure the mapper is informed of the changes
		planes = vtkPlanes()
		self.clippingBox.GetPlanes(planes)
		self._updateMapperWithClippingPlanes(planes)

	def clipVolumeRender(self, obj, evt, *args):
		"""
		clip the module based on the given clipping planes
		"""
		modules = self.getModulesToClip()
		planes = vtk.vtkPlanes()
		obj.GetPlanes(planes)
		
		for mapper in self.clippedMappers:
			mapper.RemoveAllClippingPlanes()
		self.clippedMappers = []
		
		for module in modules:
			if hasattr(module, "mapper") and hasattr(module.mapper, "SetClippingPlanes"):  
				module.mapper.SetClippingPlanes(planes)   
				self.clippedMappers.append(module.mapper)

	def picker_callback(self,obj,event):
		
		extract = vtk.vtkExtractSelectedFrustum()
	
		fPlanes=obj.GetFrustum() #collection of planes based on unscaled display
	
		#scale frustum to account for the zaspect
		scaledPlanes=vtk.vtkPlanes()
		scaledNormals=vtk.vtkDoubleArray()
		scaledNormals.SetNumberOfComponents(3)
		scaledNormals.SetNumberOfTuples(6)
		scaledOrigins=vtk.vtkPoints()
		for j in range(6):
			i=fPlanes.GetPlane(j)
			k=i.GetOrigin()
			q=i.GetNormal()
			scaledOrigins.InsertNextPoint(k[0],k[1],k[2]/float(self.Zaspect))
			scaledNormals.SetTuple(j,(q[0],q[1],q[2]*float(self.Zaspect)))
		scaledPlanes.SetNormals(scaledNormals)
		scaledPlanes.SetPoints(scaledOrigins)
			
		
		extract.SetFrustum(scaledPlanes)
		extract.SetInputData(self.vtkPntsPolyData)
		extract.Update()
		extracted = extract.GetOutput()
		
		ids = vtk.vtkIdTypeArray()
		ids = extracted.GetPointData().GetArray("vtkOriginalPointIds")

		
		if ids:
			#store them in an array for an undo operation
			self.lastSelectedIds=ids
			for i in range(ids.GetNumberOfTuples()):
				#turn them red
				self.colors.SetTuple(ids.GetValue(i),(255,0,0))
				self.bool_pnt[ids.GetValue(i)]=False
		
			self.vtkPntsPolyData.GetPointData().SetScalars(self.colors)
			self.vtkPntsPolyData.Modified()
		
		
		self.ui.vtkWidget.update()
		#set flag on ui to show that data has been modified
		self.unsaved_changes=True

    def Execute(self):

        if (self.Mesh == None):
            self.PrintError('Error: no Mesh.')

        self.Planes = vtk.vtkPlanes()
        self.Clipper = vtk.vtkClipDataSet()
        self.Clipper.SetInput(self.Mesh)
        self.Clipper.SetClipFunction(self.Planes)
        self.Clipper.GenerateClippedOutputOn()
        self.Clipper.InsideOutOn()
        
        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        self.vmtkRenderer.RegisterScript(self) 

        mapper = vtk.vtkDataSetMapper()
        mapper.SetInput(self.Mesh)
        mapper.ScalarVisibilityOff()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        self.BoxWidget = vtk.vtkBoxWidget()
        self.BoxWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
        self.BoxWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
        self.BoxWidget.GetFaceProperty().SetOpacity(0.25)

        self.vmtkRenderer.AddKeyBinding('i','Interact.', self.InteractCallback)
        self.vmtkRenderer.AddKeyBinding('space','Clip.', self.ClipCallback)

        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
        
        if self.Mesh.GetSource():
            self.Mesh.GetSource().UnRegisterAllOutputs()

	def __init__(self,gfx,iso,cropentry,entryval):
		self.gfx = gfx
		self.entry = cropentry
		self.entryval = entryval
		self.crpfn=None
		self.SetProp3D(gfx.map[0].box)
		self.planes=vtk.vtkPlanes()
		self.SetInteractor(gfx.iren)
		self.SetInput(gfx.map[0].iso.GetOutput())
		self.SetPlaceFactor(1)
		self.PlaceWidget()
		self.InsideOutOn()
		self.SetRotationEnabled(0)
		self.GetPlanes(self.planes)
		self.AddObserver("EndInteractionEvent",self.SelectPolygons)
		self.AddObserver("InteractionEvent",self.Update_crop_bounds)
		self.inorout=1
		self.init_entrys()
		(xmin,xmax,ymin,ymax,zmin,zmax)=self.gfx.map[0].box.GetBounds()
		spcing=self.gfx.map[0].reader.GetOutput().GetSpacing()
		self.old=(nint(xmin/spcing[0]),nint(xmax/spcing[0]),nint(ymin/spcing[1]),nint(ymax/spcing[1]),nint(zmin/spcing[2]),nint(zmax/spcing[2]))

 def OnBox(self, event):
     boxWidget = vtk.vtkBoxWidget()
     # change handle properties
     boxWidget.SetHandleSize(0.005) # default is 0.01
     boxWidget.SetInteractor(self.widget)
     boxWidget.SetPlaceFactor(1.25)
     boxWidget.SetInput(self.normals.GetOutput())
     boxWidget.PlaceWidget()
     boxCallback = self.BoxSelectPolygons()
     boxWidget.AddObserver("EndInteractionEvent", boxCallback)
     boxWidget.KeyPressActivationOff()
     plane = vtk.vtkPlanes()
     self.boxes.append(boxWidget)
     self.planes[boxWidget.GetAddressAsString('')] = plane
     self.region.AddFunction(plane)
     newId = self.GateMenu.AppendCheckItem(-1, "Box #" + str(self.boxCount))
     self.boxCount = self.boxCount + 1
     self.boxIds[newId.GetId()] = boxWidget.GetAddressAsString('')
     newId.Check(True)
     self.Bind(wx.EVT_MENU, self.OnBoxSelect, newId)
     boxWidget.On()