def initilize(self): self._glFunc = QOpenGLFunctions() # used in all OpenGL systems self._renderWindow = vtk.vtkGenericOpenGLRenderWindow( ) # Can not Resize # self._renderWindow = vtk.vtkExternalOpenGLRenderWindow() # Recommend; vtk-8.1.2-py3-none-any.whl self._renderer: vtk.vtkRenderer = vtk.vtkRenderer() self._renderWindow.AddRenderer(self._renderer) # * Interactor self._rwInteractor = vtk.vtkGenericRenderWindowInteractor() self._rwInteractor.EnableRenderOff() self._rwInteractor.SetRenderWindow(self._renderWindow) # * Initialize the OpenGL context for the renderer self._renderWindow.OpenGLInitContext() # * Interactor Style style = vtk.vtkInteractorStyleTrackballCamera() style.SetDefaultRenderer(self._renderer) style.SetMotionFactor(10.0) self._rwInteractor.SetInteractorStyle(style) self.__m_mouseLeftButton: QMouseEvent = None self.__m_mouseEvent: QMouseEvent = None self.__m_moveEvent: QMouseEvent = None self.__m_wheelEvent: QWheelEvent = None self.__fboItem: "QmlVTKRenderWindowInteractor" = None self.__firstRender = True self.jointPose = np.array([0, 0, 0, 0, 0, 0]) self._axis = [[0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0]] self.__jointPoseChanged = False
def __init__(self, *args): print "GtkGLExtVTKRenderWindowInteractor.__init__()" gtk.gtkgl.DrawingArea.__init__(self) self.set_double_buffered(False) #the below line used in view3 from eegview -eli self.overlayRenderer = None self._RenderWindow = vtk.vtkRenderWindow() # private attributes self.__Created = 0 self._ActiveButton = 0 self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # mcc XXX: hmm self._Iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera() self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self.ConnectSignals() # need this to be able to handle key_press events. self.set_flags(gtk.CAN_FOCUS)
def __init__(self, orientation='transverse', parent=None): super(QSliceViewWidget, self).__init__(parent) # set up vtk pipeline and create vtkWidget colors = vtk.vtkNamedColors() self.orientation = orientation self.viewer = vtk.vtkImageViewer2() self.orientations = {'coronal': 0, 'sagittal': 1, 'transverse': 2} self.viewer.SetSliceOrientation(self.orientations[self.orientation]) # get&set the camera self.camera = self.viewer.GetRenderer().GetActiveCamera() ras = [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, -1.0]] self.camera.SetPosition(ras[self.orientations[self.orientation]]) self.camera.ParallelProjectionOn() self.iren = vtk.vtkGenericRenderWindowInteractor() self.iren.SetRenderWindow(self.viewer.GetRenderWindow()) kw = {'rw': self.viewer.GetRenderWindow(), 'iren': self.iren} self.vtkWidget = QVTKRenderWindowInteractor(parent, **kw) # create QSlider self.sliderWidget = QSlider(Qt.Horizontal) # create the MainLayout of the whole widget self.MainLayout = QVBoxLayout() self.MainLayout.addWidget(self.sliderWidget) self.MainLayout.addWidget(self.vtkWidget) self.setLayout(self.MainLayout) # set the signal and slot self.sliderWidget.valueChanged.connect(self.slider_changed)
def Init(): global C,R,RW,RWI,OMW,grid_actor C=vtk.vtkCamera() R=vtk.vtkRenderer() R.SetActiveCamera(C) #R.AddActor(A) RW=vtk.vtkGenericOpenGLRenderWindow() RW.AddRenderer(R) RW.SetIsDirect(True) RW.SetSupportsOpenGL(True) RWI = vtk.vtkGenericRenderWindowInteractor() RWI.SetRenderWindow(RW) AA = vtk.vtkAxesActor() OMW = vtk.vtkOrientationMarkerWidget() OMW.SetOrientationMarker( AA ); OMW.SetInteractor( RWI ); OMW.SetEnabled( 1 ); OMW.SetInteractive(0); Lights = [] for l in bpy.context.user_preferences.system.solid_lights: L = vtk.vtkLight() L.SetLightTypeToCameraLight() L.SetDiffuseColor( l.diffuse_color ) L.SetSpecularColor( l.specular_color ) L.SetPosition( l.direction ) R.AddLight(L) Lights.append(L) grid_actor = None return R
def __init__(self): qDebug('RendererHelper::__init__()') super().__init__() self.__m_vtkFboItem = None self.gl = QOpenGLFunctions() self.__m_mouseLeftButton: QMouseEvent = None self.__m_mouseEvent: QMouseEvent = None self.__m_moveEvent: QMouseEvent = None self.__m_wheelEvent: QWheelEvent = None self.__m_firstRender: bool = True self.renderWindow: vtk.vtkGenericOpenGLRenderWindow = vtk.vtkGenericOpenGLRenderWindow( ) self.renderer: vtk.vtkRenderer = vtk.vtkRenderer() self.renderWindow.AddRenderer(self.renderer) # * Interactor self.interactor: vtk.vtkGenericRenderWindowInteractor = vtk.vtkGenericRenderWindowInteractor( ) self.interactor.EnableRenderOff() self.renderWindow.SetInteractor(self.interactor) # * Initialize the OpenGL context for the renderer self.renderWindow.OpenGLInitContext() # * Interactor Style style = vtk.vtkInteractorStyleTrackballCamera() style.SetDefaultRenderer(self.renderer) style.SetMotionFactor(10.0) self.interactor.SetInteractorStyle(style)
def __init__(self, parent=None): super(QVolumeViewWidget, self).__init__(parent) # set up vtk pipeline and create vtkWidget self.renw = vtk.vtkRenderWindow() self.iren = vtk.vtkGenericRenderWindowInteractor() self.iren.SetRenderWindow(self.renw) kw = {'rw': self.renw, 'iren': self.iren} self.vtkWidget = QVTKRenderWindowInteractor(parent, **kw) self.MainLayout = QVBoxLayout() self.MainLayout.addWidget(self.vtkWidget) self.setLayout(self.MainLayout) # self.vtkWidget = QVTKRenderWindowInteractor() self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) # add the orientation marker widget self.axes = vtk.vtkAxesActor() self.widget = vtk.vtkOrientationMarkerWidget() xyzLabels = ['R', 'A', 'S'] self.axes.SetXAxisLabelText(xyzLabels[0]) self.axes.SetYAxisLabelText(xyzLabels[1]) self.axes.SetZAxisLabelText(xyzLabels[2]) self.widget.SetOrientationMarker(self.axes) self.widget.SetInteractor(self.vtkWidget) self.widget.SetViewport(0.8, 0.0, 1, 0.3) self.widget.SetEnabled(True) self.widget.InteractiveOn() self.picker = vtk.vtkVolumePicker()
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags|QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() self._RenderWindow.SetWindowInfo(str(int(self.winId()))) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', messenger.send) messenger.connect(self._Iren, 'CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', messenger.send) messenger.connect(self._Iren, 'DestroyTimerEvent', self.DestroyTimer) render_window = self._Iren.GetRenderWindow() render_window.AddObserver('CursorChangedEvent', messenger.send) messenger.connect(render_window, 'CursorChangedEvent', self.CursorChangedEvent)
def createRenderWindow( self, **args ): blocking = args.get( 'blocking', False ) renWin = args.get( 'renwin', None ) if renWin == None: renWin = vtk.vtkRenderWindow() rendWinInteractor = renWin.GetInteractor() if rendWinInteractor == None: rendWinInteractor = vtk.vtkRenderWindowInteractor() if blocking else vtk.vtkGenericRenderWindowInteractor() renWin.SetInteractor( rendWinInteractor ) rendWinInteractor.SetRenderWindow(renWin) self.renderWindowInteractor = rendWinInteractor self.renderer = vtk.vtkRenderer() renWin.AddRenderer( self.renderer ) self.interactorStyle = vtk.vtkInteractorStyleTrackballCamera( ) self.renderWindowInteractor.SetInteractorStyle( self.interactorStyle ) self.interactorStyle.KeyPressActivationOff( ) self.interactorStyle.SetEnabled(1) if self.useDepthPeeling: self.renderer.UseDepthPeelingOn( ) self.renderer.SetOcclusionRatio( 0.2 ) renWin.SetAlphaBitPlanes( 1 ) renWin.SetMultiSamples( 0 ) self.renderer.SetBackground(1.0, 1.0, 1.0) self.renderer.SetNearClippingPlaneTolerance( 0.0001 ) self.renderWindow = renWin
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags|QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() self._RenderWindow.SetWindowInfo(str(int(self.winId()))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if kw.has_key('iren'): self._Iren = kw['iren'] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent)
def __init__(self, parent=None, name=None, *args, **kw): # the current button self._ActiveButton = 0 # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveState = 0 self.__connected = 0 # is QT->VTK connection done? # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 del kw['stereo'] rw = None if kw.has_key('rw'): rw = kw['rw'] del kw['rw'] # create qt-level widget # You cannot pass kw anymore, you'll a TypeError: keyword arguments are not supported # http://goldenspud.com/webrog/archives/2004/07/20/pyqt-platform-inconsistencies/ apply(qt.QWidget.__init__, (self,parent,name) + args) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setBackgroundMode(qt.Qt.NoBackground) self.setMouseTracking(1) # get all mouse events self.setFocusPolicy(qt.QWidget.ClickFocus) if parent == None: self.show() self._Timer = qt.QTimer(self, 'timer handler') self.connect(self._Timer, qt.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer)
def __init__(self, parent=None, name=None, *args, **kw): # the current button self._ActiveButton = 0 # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveState = 0 self.__connected = 0 # is QT->VTK connection done? # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 del kw['stereo'] rw = None if kw.has_key('rw'): rw = kw['rw'] del kw['rw'] # create qt-level widget # You cannot pass kw anymore, you'll a TypeError: keyword arguments are not supported # http://goldenspud.com/webrog/archives/2004/07/20/pyqt-platform-inconsistencies/ apply(qt.QWidget.__init__, (self, parent, name) + args) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setBackgroundMode(qt.Qt.NoBackground) self.setMouseTracking(1) # get all mouse events self.setFocusPolicy(qt.QWidget.ClickFocus) if parent == None: self.show() self._Timer = qt.QTimer(self, 'timer handler') self.connect(self._Timer, qt.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer)
def __init__(self): super(QmlVTKOpenGLRenderWindowInteractor, self).__init__() self._glFunc = QOpenGLFunctions() self._RenderWindow = vtk.vtkGenericOpenGLRenderWindow() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._ren = vtk.vtkRenderer() self._RenderWindow.AddRenderer(self._ren) self._Iren.SetRenderWindow(self._RenderWindow) self._RenderWindow.OpenGLInitContext()
def __init__(self, master, cnf={}, **kw): """ Constructor. Keyword arguments: rw -- Use passed render window instead of creating a new one. stereo -- If True, generate a stereo-capable window. Defaults to False. focus_on_enter -- If True, use a focus-follows-mouse mode. Defaults to False where the widget will use a click-to-focus mode. """ # load the necessary extensions into tk vtkLoadPythonTkWidgets(master.tk) try: # check to see if a render window was specified renderWindow = kw['rw'] except KeyError: renderWindow = vtk.vtkRenderWindow() try: # was a stereo rendering context requested? if kw['stereo']: renderWindow.StereoCapableWindowOn() del kw['stereo'] except KeyError: pass # check if focus should follow mouse if kw.get('focus_on_enter'): self._FocusOnEnter = 1 del kw['focus_on_enter'] else: self._FocusOnEnter = 0 kw['rw'] = renderWindow.GetAddressAsString("vtkRenderWindow") Tkinter.Widget.__init__(self, master, 'vtkTkRenderWidget', cnf, kw) self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._OldFocus = None # private attributes self.__InExpose = 0 # create the Tk bindings self.BindEvents()
def createRenderWindow(self, blocking=False): self.renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() if self.useDepthPeeling: self.renderer.UseDepthPeelingOn() self.renderer.SetOcclusionRatio(0.2) renWin.SetAlphaBitPlanes(1) renWin.SetMultiSamples(0) renWin.AddRenderer(self.renderer) self.renderWindowInteractor = vtk.vtkRenderWindowInteractor( ) if blocking else vtk.vtkGenericRenderWindowInteractor() self.renderWindowInteractor.SetRenderWindow(renWin) return renWin
def __init__(self, *args): gtk.gtkgl.DrawingArea.__init__(self) self.set_double_buffered(gtk.FALSE) self._RenderWindow = vtk.vtkRenderWindow() # private attributes self.__Created = 0 self._ActiveButton = 0 self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) self._Iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera() self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self.ConnectSignals() # need this to be able to handle key_press events. self.set_flags(gtk.CAN_FOCUS)
def initialize(self): global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor # Bring used components self.registerVtkWebProtocol(protocols.vtkWebMouseHandler()) self.registerVtkWebProtocol(protocols.vtkWebViewPort()) self.registerVtkWebProtocol(protocols.vtkWebViewPortImageDelivery()) self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery()) # Update authentication key to use self.updateSecret(_WebCone.authKey) # Create default pipeline (Only once for all the session) if not _WebCone.view: # VTK specific code renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.OffScreenRenderingOn() renderWindowInteractor = vtk.vtkGenericRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.GetInteractorStyle( ).SetCurrentStyleToTrackballCamera() cone = vtk.vtkConeSource() mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(cone.GetOutputPort()) actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() renderWindow.Render() # VTK Web application specific _WebCone.view = renderWindow self.getApplication().GetObjectIdMap().SetActiveObject( "VIEW", renderWindow)
def initialize(self): global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor # Bring used components self.registerVtkWebProtocol(protocols.vtkWebMouseHandler()) self.registerVtkWebProtocol(protocols.vtkWebViewPort()) self.registerVtkWebProtocol(protocols.vtkWebViewPortImageDelivery()) self.registerVtkWebProtocol(protocols.vtkWebViewPortGeometryDelivery()) # Update authentication key to use self.updateSecret(_WebCone.authKey) # Create default pipeline (Only once for all the session) if not _WebCone.view: # VTK specific code renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.OffScreenRenderingOn() renderWindowInteractor = vtk.vtkGenericRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera() cone = vtk.vtkConeSource() mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(cone.GetOutputPort()) actor.SetMapper(mapper) renderer.AddActor(actor) renderer.ResetCamera() renderWindow.Render() # VTK Web application specific _WebCone.view = renderWindow self.getApplication().GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def __init__(self, *args, **kwargs): qDebug('FboItem::__init__') QQuickFramebufferObject.__init__(self) self._vtkFboRenderer = None BasePlotter.__init__(self, *args, **kwargs) self._opts = { 'border': None, 'border_color': 'k', 'border_width': 2.0, } common_keys = self._opts.keys() & kwargs.keys() common_dict = {k: kwargs[k] for k in common_keys} self._opts.update(common_dict) self.ren_win = vtk.vtkGenericOpenGLRenderWindow = vtk.vtkGenericOpenGLRenderWindow( ) self.iren: vtk.vtkGenericRenderWindowInteractor = vtk.vtkGenericRenderWindowInteractor( ) self.iren.EnableRenderOff() self.ren_win.SetInteractor(self.iren) self.update_style() self.__m_lastMouseLeftButton: QMouseEvent = QMouseEvent( QEvent.Type.None_, QPointF(0, 0), Qt.NoButton, Qt.NoButton, Qt.NoModifier) self.__m_lastMouseButton: QMouseEvent = QMouseEvent( QEvent.Type.None_, QPointF(0, 0), Qt.NoButton, Qt.NoButton, Qt.NoModifier) self.__m_lastMouseMove: QMouseEvent = QMouseEvent( QEvent.Type.None_, QPointF(0, 0), Qt.NoButton, Qt.NoButton, Qt.NoModifier) self.__m_lastMouseWheel: QWheelEvent = None self.setMirrorVertically( True) # QtQuick and OpenGL have opposite Y-Axis directions self.setAcceptedMouseButtons(Qt.RightButton | Qt.LeftButton)
def __init__(self, *args): l = list(args) attr = (gtkgl.RGBA, gtkgl.DOUBLEBUFFER) l.insert(0, self) l.insert(1, attr) apply(gtkgl.GtkGLArea.__init__, l) self._RenderWindow = vtk.vtkRenderWindow() # private attributes self.__Created = 0 self._ActiveButton = 0 self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self.ConnectSignals() # need this to be able to handle key_press events. self.set_flags(gtk.CAN_FOCUS) # default size self.set_usize(300, 300)
def __init__(self, parent=None, **kw): logging.debug("In QVTKRenderWindowInteractor::__init__()") # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget #QtGui.QWidget.__init__(self, parent) #QtOpenGL.QGLWidget.__init__(self, parent) super(QVTKRenderWindowInteractor, self).__init__(parent) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtkRenderWindow() if sys.platform == "win32": self._RenderWindow.SetWindowInfo( str(int(pythonapi.PyCObject_AsVoidPtr(self.winId())))) else: self._RenderWindow.SetWindowInfo(str(int(self.winId()))) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy( QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent)
def __init__(self, parent, ID, *args, **kw): """Default class constructor. Parameters ---------- parent parent window ID window identifier kw wxPython keywords (position, size, style) plus the 'stereo' keyword """ # private attributes self.__RenderWhenDisabled = 0 # First do special handling of some keywords: # stereo, position, size, style stereo = 0 if kw.has_key("stereo"): if kw["stereo"]: stereo = 1 del kw["stereo"] elif self.USE_STEREO: stereo = 1 position, size = wx.DefaultPosition, wx.DefaultSize if kw.has_key("position"): position = kw["position"] del kw["position"] if kw.has_key("size"): size = kw["size"] del kw["size"] # wx.WANTS_CHARS says to give us e.g. TAB # wx.NO_FULL_REPAINT_ON_RESIZE cuts down resize flicker under GTK style = wx.WANTS_CHARS | wx.NO_FULL_REPAINT_ON_RESIZE if kw.has_key("style"): style = style | kw["style"] del kw["style"] # the enclosing frame must be shown under GTK or the windows # don't connect together properly if wx.Platform != "__WXMSW__": l = [] p = parent while p: # make a list of all parents l.append(p) p = p.GetParent() l.reverse() # sort list into descending order for p in l: p.Show(1) if baseClass.__name__ == "GLCanvas": # code added by cpbotha to enable stereo and double # buffering correctly where the user requests this; remember # that the glXContext in this case is NOT allocated by VTK, # but by WX, hence all of this. # Initialize GLCanvas with correct attriblist attribList = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_MIN_RED, 1, wx.glcanvas.WX_GL_MIN_GREEN, 1, wx.glcanvas.WX_GL_MIN_BLUE, 1, wx.glcanvas.WX_GL_DEPTH_SIZE, 16, wx.glcanvas.WX_GL_DOUBLEBUFFER, ] if stereo: attribList.append(wx.glcanvas.WX_GL_STEREO) try: baseClass.__init__(self, parent, ID, position, size, style, attribList=attribList) except wx.PyAssertionError: # visual couldn't be allocated, so we go back to default baseClass.__init__(self, parent, ID, position, size, style) if stereo: # and make sure everyone knows that the stereo # visual wasn't set. stereo = 0 else: baseClass.__init__(self, parent, ID, position, size, style) # create the RenderWindow and initialize it self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(vtk.vtkRenderWindow()) self._Iren.AddObserver("CreateTimerEvent", self.CreateTimer) self._Iren.AddObserver("DestroyTimerEvent", self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver("CursorChangedEvent", self.CursorChangedEvent) try: self._Iren.GetRenderWindow().SetSize(size.width, size.height) except AttributeError: self._Iren.GetRenderWindow().SetSize(size[0], size[1]) if stereo: self._Iren.GetRenderWindow().StereoCapableWindowOn() self._Iren.GetRenderWindow().SetStereoTypeToCrystalEyes() self.__handle = None self.BindEvents() # with this, we can make sure that the reparenting logic in # Render() isn't called before the first OnPaint() has # successfully been run (and set up the VTK/WX display links) self.__has_painted = False # set when we have captured the mouse. self._own_mouse = False # used to store WHICH mouse button led to mouse capture self._mouse_capture_button = 0 # A mapping for cursor changes. self._cursor_map = { 0: wx.CURSOR_ARROW, # VTK_CURSOR_DEFAULT 1: wx.CURSOR_ARROW, # VTK_CURSOR_ARROW 2: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZENE 3: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZENWSE 4: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZESW 5: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZESE 6: wx.CURSOR_SIZENS, # VTK_CURSOR_SIZENS 7: wx.CURSOR_SIZEWE, # VTK_CURSOR_SIZEWE 8: wx.CURSOR_SIZING, # VTK_CURSOR_SIZEALL 9: wx.CURSOR_HAND, # VTK_CURSOR_HAND 10: wx.CURSOR_CROSS, # VTK_CURSOR_CROSSHAIR }
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags | QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if kw.has_key('iren'): self._Iren = kw['iren'] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy( QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QtGui.QWidget(self) self._hidden.hide() self.connect(self._hidden, QtCore.SIGNAL('destroyed()'), self.Finalize)
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key("stereo"): if kw["stereo"]: stereo = 1 rw = None if kw.has_key("rw"): rw = kw["rw"] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags | QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() if qt_api == "pyqt" or sys.platform != "win32": self._RenderWindow.SetWindowInfo(str(int(self.winId()))) else: # On Windows PySide has a bug with winID() function, so this is fix: self._RenderWindow.SetWindowInfo(str(int(pythonapi.PyCObject_AsVoidPtr(self.winId())))) self._should_set_parent_info = sys.platform == "win32" if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL("timeout()"), self.TimerEvent) self._Iren.AddObserver("CreateTimerEvent", messenger.send) messenger.connect(self._Iren, "CreateTimerEvent", self.CreateTimer) self._Iren.AddObserver("DestroyTimerEvent", messenger.send) messenger.connect(self._Iren, "DestroyTimerEvent", self.DestroyTimer) render_window = self._Iren.GetRenderWindow() render_window.AddObserver("CursorChangedEvent", messenger.send) messenger.connect(render_window, "CursorChangedEvent", self.CursorChangedEvent)
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags | QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() if qt_api == 'pyqt' or sys.platform != 'win32': self._RenderWindow.SetWindowInfo(str(int(self.winId()))) else: # On Windows PySide has a bug with winID() function, so this is fix: self._RenderWindow.SetWindowInfo( str(int(pythonapi.PyCObject_AsVoidPtr(self.winId())))) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy( QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', messenger.send) messenger.connect(self._Iren, 'CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', messenger.send) messenger.connect(self._Iren, 'DestroyTimerEvent', self.DestroyTimer) render_window = self._Iren.GetRenderWindow() render_window.AddObserver('CursorChangedEvent', messenger.send) messenger.connect(render_window, 'CursorChangedEvent', self.CursorChangedEvent)
def __init__(self, parent, ID, *args, **kw): self.__RenderWhenDisabled = 0 stereo = 0 if 'stereo' in kw: if kw['stereo']: stereo = 1 del kw['stereo'] elif self.USE_STEREO: stereo = 1 position, size = wx.DefaultPosition, wx.DefaultSize if 'position' in kw: position = kw['position'] del kw['position'] if 'size' in kw: size = kw['size'] del kw['size'] style = wx.WANTS_CHARS | wx.NO_FULL_REPAINT_ON_RESIZE if 'style' in kw: style = style | kw['style'] del kw['style'] if wx.Platform != '__WXMSW__': l = [] p = parent while p: l.append(p) p = p.GetParent() l.reverse() for p in l: p.Show(1) if baseClass.__name__ == 'GLCanvas': attribList = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_MIN_RED, 1, wx.glcanvas.WX_GL_MIN_GREEN, 1, wx.glcanvas.WX_GL_MIN_BLUE, 1, wx.glcanvas.WX_GL_DEPTH_SIZE, 16, wx.glcanvas.WX_GL_DOUBLEBUFFER ] if stereo: attribList.append(wx.glcanvas.WX_GL_STEREO) try: baseClass.__init__(self, parent, ID, pos=position, size=size, style=style, attribList=attribList) except wx.PyAssertionError: baseClass.__init__(self, parent, ID, pos=position, size=size, style=style) if stereo: stereo = 0 else: baseClass.__init__(self, parent, ID, position, size, style) self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(vtk.vtkRenderWindow()) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) try: self._Iren.GetRenderWindow().SetSize(size.width, size.height) except AttributeError: self._Iren.GetRenderWindow().SetSize(size[0], size[1]) if stereo: self._Iren.GetRenderWindow().StereoCapableWindowOn() self._Iren.GetRenderWindow().SetStereoTypeToCrystalEyes() self.__handle = None self.mouse_zone = False self.left_mouse_down = False self.mousex = 0 self.mousey = 0 self.BindEvents() self.__has_painted = False self._own_mouse = False self._mouse_capture_button = 0 self._cursor_map = { 0: wx.CURSOR_ARROW, 1: wx.CURSOR_ARROW, 2: wx.CURSOR_SIZENESW, 3: wx.CURSOR_SIZENWSE, 4: wx.CURSOR_SIZENESW, 5: wx.CURSOR_SIZENWSE, 6: wx.CURSOR_SIZENS, 7: wx.CURSOR_SIZEWE, 8: wx.CURSOR_SIZING, 9: wx.CURSOR_HAND, 10: wx.CURSOR_CROSS, }
def __init__(self, parent, ID, *args, **kw): # private attributes self.__RenderWhenDisabled = 0 # First do special handling of some keywords: # stereo, position, size, width, height, style stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 del kw['stereo'] elif self.USE_STEREO: stereo = 1 position = wxDefaultPosition if kw.has_key('position'): position = kw['position'] del kw['position'] size = wxDefaultSize if kw.has_key('size'): size = kw['size'] del kw['size'] if kw.has_key('width') and kw.has_key('height'): size = (kw['width'], kw['height']) del kw['width'] del kw['height'] # wxWANTS_CHARS says to give us e.g. TAB # wxNO_FULL_REPAINT_ON_RESIZE cuts down resize flicker under GTK style = wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE if kw.has_key('style'): style = style | kw['style'] del kw['style'] # the enclosing frame must be shown under GTK or the windows # don't connect together properly l = [] p = parent while p: # make a list of all parents l.append(p) p = p.GetParent() l.reverse() # sort list into descending order for p in l: p.Show(1) # code added by cpbotha to enable stereo correctly where the user # requests this; remember that the glXContext in this case is NOT # allocated by VTK, but by WX, hence all of this. if stereo and baseClass.__name__ == 'wxGLCanvas': # initialize GLCanvas with correct attriblist for stereo attribList = [WX_GL_RGBA, WX_GL_MIN_RED, 1, WX_GL_MIN_GREEN, 1, WX_GL_MIN_BLUE, 1, WX_GL_DEPTH_SIZE, 1, WX_GL_DOUBLEBUFFER, WX_GL_STEREO] try: baseClass.__init__(self, parent, ID, position, size, style, attribList=attribList) except wxPyAssertionError: # stereo visual couldn't be allocated, so we go back to default baseClass.__init__(self, parent, ID, position, size, style) # and make sure everyone knows about it stereo = 0 else: baseClass.__init__(self, parent, ID, position, size, style) # create the RenderWindow and initialize it self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow( vtk.vtkRenderWindow() ) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) try: self._Iren.GetRenderWindow().SetSize(size.width, size.height) except AttributeError: self._Iren.GetRenderWindow().SetSize(size[0], size[1]) if stereo: self._Iren.GetRenderWindow().StereoCapableWindowOn() self._Iren.GetRenderWindow().SetStereoTypeToCrystalEyes() self.__handle = None self._ActiveButton = 0 self.BindEvents() # with this, we can make sure that the reparenting logic in # Render() isn't called before the first OnPaint() has # successfully been run (and set up the VTK/WX display links) self.__has_painted = False
def __init__(self, parent, ID, *args, **kw): """Default class constructor. @param parent: parent window @param ID: window id @param **kw: wxPython keywords (position, size, style) plus the 'stereo' keyword """ # private attributes self.__RenderWhenDisabled = 0 # First do special handling of some keywords: # stereo, position, size, width, height, style try: stereo = bool(kw['stereo']) del kw['stereo'] except KeyError: stereo = False try: position = kw['position'] del kw['position'] except KeyError: position = wx.DefaultPosition try: size = kw['size'] del kw['size'] except KeyError: try: size = parent.GetSize() except AttributeError: size = wx.DefaultSize # wx.WANTS_CHARS says to give us e.g. TAB # wx.NO_FULL_REPAINT_ON_RESIZE cuts down resize flicker under GTK style = wx.WANTS_CHARS | wx.NO_FULL_REPAINT_ON_RESIZE try: style = style | kw['style'] del kw['style'] except KeyError: pass # the enclosing frame must be shown under GTK or the windows # don't connect together properly if wx.Platform != '__WXMSW__': l = [] p = parent while p: # make a list of all parents l.append(p) p = p.GetParent() l.reverse() # sort list into descending order for p in l: p.Show(1) if baseClass.__name__ == 'GLCanvas': # code added by cpbotha to enable stereo and double # buffering correctly where the user requests this; remember # that the glXContext in this case is NOT allocated by VTK, # but by WX, hence all of this. # Initialize GLCanvas with correct attriblist attribList = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_MIN_RED, 1, wx.glcanvas.WX_GL_MIN_GREEN, 1, wx.glcanvas.WX_GL_MIN_BLUE, 1, wx.glcanvas.WX_GL_DEPTH_SIZE, 16, wx.glcanvas.WX_GL_DOUBLEBUFFER ] if stereo: attribList.append(wx.glcanvas.WX_GL_STEREO) try: baseClass.__init__(self, parent, ID, pos=position, size=size, style=style, attribList=attribList) except wx.PyAssertionError: # visual couldn't be allocated, so we go back to default baseClass.__init__(self, parent, ID, pos=position, size=size, style=style) if stereo: # and make sure everyone knows that the stereo # visual wasn't set. stereo = 0 else: baseClass.__init__(self, parent, ID, pos=position, size=size, style=style) # create the RenderWindow and initialize it self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(vtk.vtkRenderWindow()) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) try: self._Iren.GetRenderWindow().SetSize(size.width, size.height) except AttributeError: self._Iren.GetRenderWindow().SetSize(size[0], size[1]) if stereo: self._Iren.GetRenderWindow().StereoCapableWindowOn() self._Iren.GetRenderWindow().SetStereoTypeToCrystalEyes() self.__handle = None self.BindEvents() # with this, we can make sure that the reparenting logic in # Render() isn't called before the first OnPaint() has # successfully been run (and set up the VTK/WX display links) self.__has_painted = False # set when we have captured the mouse. self._own_mouse = False # used to store WHICH mouse button led to mouse capture self._mouse_capture_button = 0 # A mapping for cursor changes. self._cursor_map = { 0: wx.CURSOR_ARROW, # VTK_CURSOR_DEFAULT 1: wx.CURSOR_ARROW, # VTK_CURSOR_ARROW 2: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZENE 3: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZENWSE 4: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZESW 5: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZESE 6: wx.CURSOR_SIZENS, # VTK_CURSOR_SIZENS 7: wx.CURSOR_SIZEWE, # VTK_CURSOR_SIZEWE 8: wx.CURSOR_SIZING, # VTK_CURSOR_SIZEALL 9: wx.CURSOR_HAND, # VTK_CURSOR_HAND 10: wx.CURSOR_CROSS, # VTK_CURSOR_CROSSHAIR }
def __init__(self, parent=None, ID=-1, *args, **kw): # First do special handling of some keywords: # stereo, position, size, width, height, style stereo = 0 self._last_mouse_pos = None self.__is_frozen = False if 'stereo' in kw: if kw['stereo']: stereo = 1 del kw['stereo'] position = wx.DefaultPosition if 'position' in kw: position = kw['position'] del kw['position'] size = wx.DefaultSize if 'size' in kw: size = kw['size'] if not isinstance(size, wx.Size): size = wx.Size(*size) del kw['size'] if 'width' in kw and 'height' in kw: size = wx.Size(kw['width'], kw['height']) del kw['width'] del kw['height'] # wx.WANTS_CHARS says to give us e.g. TAB # wx.NO_FULL_REPAINT_ON_RESIZE cuts down resize flicker under GTK style = wx.WANTS_CHARS | wx.NO_FULL_REPAINT_ON_RESIZE if 'style' in kw: style = style | kw['style'] del kw['style'] # if there is no parent, make a frame window if parent is None: parent = wx.Frame(None, -1, "wxRenderWindow", position, size) parent.Show(1) self._wxFrame = parent # initialize the wxWindow -- take care here to ensure double-buffering is # enabled under Linux if wx.Platform != '__WXMSW__': attribList = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_DOUBLEBUFFER, wx.glcanvas.WX_GL_DEPTH_SIZE, 16 ] baseClass.__init__(self, parent, id=ID, pos=position, size=size, style=style, attribList=attribList) else: baseClass.__init__(self, parent, ID, position, size, style) # create the RenderWindow and initialize it self._RenderWindow = vtk.vtkRenderWindow() self.__Created = 0 # create the RenderWindow and initialize it self._RenderWindowInteractor = vtk.vtkGenericRenderWindowInteractor() self._RenderWindowInteractor.SetRenderWindow(self._RenderWindow) self._RenderWindowInteractor.GetRenderWindow().AddObserver( 'CursorChangedEvent', self.CursorChangedEvent) try: self._RenderWindowInteractor.GetRenderWindow().SetSize( size.width, size.height) except AttributeError: self._RenderWindowInteractor.GetRenderWindow().SetSize( size[0], size[1]) if stereo: self._RenderWindowInteractor.GetRenderWindow( ).StereoCapableWindowOn() self._RenderWindowInteractor.GetRenderWindow( ).SetStereoTypeToCrystalEyes() # The superclass can't be initialized until _RenderWindow # has been declared. PaneFrame.PaneFrame.__init__(self) self.__handle = None self.__has_painted = False self.__is_mapped = False self._own_mouse = False self._mouse_capture_button = 0 self._cursor_map = { 0: wx.CURSOR_ARROW, # VTK_CURSOR_DEFAULT 1: wx.CURSOR_ARROW, # VTK_CURSOR_ARROW 2: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZENE 3: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZENWSE 4: wx.CURSOR_SIZENESW, # VTK_CURSOR_SIZESW 5: wx.CURSOR_SIZENWSE, # VTK_CURSOR_SIZESE 6: wx.CURSOR_SIZENS, # VTK_CURSOR_SIZENS 7: wx.CURSOR_SIZEWE, # VTK_CURSOR_SIZEWE 8: wx.CURSOR_SIZING, # VTK_CURSOR_SIZEALL 9: wx.CURSOR_HAND, # VTK_CURSOR_HAND 10: wx.CURSOR_CROSS, # VTK_CURSOR_CROSSHAIR } # private variable for better Enter/Leave handling self.__ActiveButton = 0 self.__SaveState = 0 self._Inside = 0 # refresh window by doing a Render self.Bind(wx.EVT_PAINT, self.OnPaint) # turn off background erase to reduce flicker self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None) # Bind the events to the event converters self.Bind(wx.EVT_RIGHT_DOWN, self.OnButtonDown) self.Bind(wx.EVT_LEFT_DOWN, self.OnButtonDown) self.Bind(wx.EVT_MIDDLE_DOWN, self.OnButtonDown) self.Bind(wx.EVT_RIGHT_UP, self.OnButtonUp) self.Bind(wx.EVT_LEFT_UP, self.OnButtonUp) self.Bind(wx.EVT_MIDDLE_UP, self.OnButtonUp) # double click events self.Bind(wx.EVT_RIGHT_DCLICK, self.OnButtonDClick) self.Bind(wx.EVT_LEFT_DCLICK, self.OnButtonDClick) self.Bind(wx.EVT_MIDDLE_DCLICK, self.OnButtonDClick) self.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel) self.Bind(wx.EVT_MOTION, self.OnMotion) self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter) self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave) # If we use EVT_KEY_DOWN instead of EVT_CHAR, capital versions # of all characters are always returned. EVT_CHAR also performs # other necessary keyboard-dependent translations. self.Bind(wx.EVT_CHAR, self.OnKeyDown) self.Bind(wx.EVT_KEY_UP, self.OnKeyUp) self.Bind(wx.EVT_SIZE, self.OnSize) # the wx 2.8.7.1 documentation states that you HAVE to handle # this event if you make use of CaptureMouse, which we do. if _useCapture and hasattr(wx, 'EVT_MOUSE_CAPTURE_LOST'): self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, self.OnMouseCaptureLost) # pretend that we're a base window - let atamai help us out self._BindInteractor() # debug debug debug return # Bind the events to the event converters wx.EVT_MOUSE_EVENTS(self, self.ConvertMouseEvent) wx.EVT_KEY_DOWN(self, self.ConvertKeyEvent) wx.EVT_KEY_UP(self, self.ConvertKeyEvent) wx.EVT_SIZE(self, self.ConvertSizeEvent) # wx.EVT_MOVE(self, self.ConvertMoveEvent) wx.EVT_SET_FOCUS(self, self.ConvertFocusEvent) wx.EVT_KILL_FOCUS(self, self.ConvertFocusEvent)
def __init__(self, parent=None, **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton self.__wheelDelta = 0 # do special handling of some keywords: # stereo, rw try: stereo = bool(kw['stereo']) except KeyError: stereo = False try: rw = kw['rw'] except KeyError: rw = None # create base qt-level widget if QVTKRWIBase == "QWidget": if "wflags" in kw: wflags = kw['wflags'] else: wflags = Qt.WindowFlags() QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC) elif QVTKRWIBase == "QGLWidget": QGLWidget.__init__(self, parent) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() # Python2 if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) # Python3 elif type(WId).__name__ == 'PyCapsule': from ctypes import pythonapi, c_void_p, py_object, c_char_p pythonapi.PyCapsule_GetName.restype = c_char_p pythonapi.PyCapsule_GetName.argtypes = [py_object] name = pythonapi.PyCapsule_GetName(WId) pythonapi.PyCapsule_GetPointer.restype = c_void_p pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p] WId = pythonapi.PyCapsule_GetPointer(WId, name) self._RenderWindow.SetWindowInfo(str(int(WId))) # # if stereo: # stereo mode # self._RenderWindow.StereoCapableWindowOn() # self._RenderWindow.SetStereoTypeToCrystalEyes() try: self._Iren = kw['iren'] except KeyError: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # this is needed to get nice'n'smooth mouse interaction self.interactorStyle = vtk.vtkInteractorStyleSwitch() # self.interactorStyle.SetCurrentStyleToTrackballActor() self.interactorStyle.SetCurrentStyleToTrackballCamera() self._Iren.SetInteractorStyle(self.interactorStyle) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize) self.mousePressEventFcn = self.mousePressEvent2DStyle
def __init__(self, parent=None, wflags=Qt.WindowFlags()): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton # create qt-level widget glFormat = QtOpenGL.QGLFormat() glFormat.setAlpha(True) QtOpenGL.QGLWidget.__init__(self, glFormat, parent, None) # Create a wender window self._RenderWindow = vtk.vtkRenderWindow() self._RenderWindow.SetAlphaBitPlanes(1) self._RenderWindow.SetMultiSamples(0) # Create a renderer self._Renderer = vtk.vtkRenderer() self._Renderer.SetUseDepthPeeling(1) #self._Renderer.SetMaximumNumberOfPeels(100) #self._Renderer.SetOcclusionRatio(0.0) self._RenderWindow.AddRenderer(self._Renderer) WId = self.winId() # Python2 if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) # Python3 elif type(WId).__name__ == 'PyCapsule': from ctypes import pythonapi, c_void_p, py_object, c_char_p pythonapi.PyCapsule_GetName.restype = c_char_p pythonapi.PyCapsule_GetName.argtypes = [py_object] name = pythonapi.PyCapsule_GetName(WId) pythonapi.PyCapsule_GetPointer.restype = c_void_p pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p] WId = pythonapi.PyCapsule_GetPointer(WId, name) self._RenderWindow.SetWindowInfo(str(int(WId))) self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def createRenderWindow( self, blocking = False ): self.renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() if self.useDepthPeeling: self.renderer.UseDepthPeelingOn( ) self.renderer.SetOcclusionRatio( 0.2 ) renWin.SetAlphaBitPlanes( 1 ) renWin.SetMultiSamples( 0 ) renWin.AddRenderer( self.renderer ) self.renderWindowInteractor = vtk.vtkRenderWindowInteractor() if blocking else vtk.vtkGenericRenderWindowInteractor() self.renderWindowInteractor.SetRenderWindow(renWin) return renWin
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key("stereo"): if kw["stereo"]: stereo = 1 rw = None if kw.has_key("rw"): rw = kw["rw"] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags | QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() if type(WId).__name__ == "PyCObject": from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if kw.has_key("iren"): self._Iren = kw["iren"] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL("timeout()"), self.TimerEvent) self._Iren.AddObserver("CreateTimerEvent", self.CreateTimer) self._Iren.AddObserver("DestroyTimerEvent", self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver("CursorChangedEvent", self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed before # its parent thus allowing cleanup of VTK elements. self._hidden = QtGui.QWidget(self) self._hidden.hide() self.connect(self._hidden, QtCore.SIGNAL("destroyed()"), self.Finalize)
def __init__(self, parent=None, wflags=Qt.WindowFlags(), **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton self.__fullScreenAction = QAction(parent) # do special handling of some keywords: # stereo, rw stereo = 0 if "stereo" in kw: if kw["stereo"]: stereo = 1 rw = None if "rw" in kw: rw = kw["rw"] # create qt-level widget QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC) # Add full screen shortcut self.__fullScreenAction.setShortcut(QKeySequence.FullScreen) self.__fullScreenAction.setCheckable(True) self.__fullScreenAction.setChecked(False) self.__fullScreenAction.triggered.connect(self.toggleFullScreen) QWidget.addAction(self, self.__fullScreenAction) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() if type(WId).__name__ == "PyCObject": from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if "iren" in kw: self._Iren = kw["iren"] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver("CreateTimerEvent", self.CreateTimer) self._Iren.AddObserver("DestroyTimerEvent", self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver("CursorChangedEvent", self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed before # its parent thus allowing cleanup of VTK elements. # self._hidden = QtGui.QWidget(self) self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags|QtCore.Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() self._RenderWindow.SetWindowInfo(str(int(self.winId()))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if kw.has_key('iren'): self._Iren = kw['iren'] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QtGui.QWidget(self) self._hidden.hide() self.connect(self._hidden, QtCore.SIGNAL('destroyed()'), self.Finalize)
def __init__(self, parent, ID, *args, **kw): """Default class constructor. @param parent: parent window @param ID: window id @param **kw: wxPython keywords (position, size, style) plus the 'stereo' keyword """ # private attributes self.__RenderWhenDisabled = 0 # First do special handling of some keywords: # stereo, position, size, style stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 del kw['stereo'] elif self.USE_STEREO: stereo = 1 position, size = wx.DefaultPosition, wx.DefaultSize if kw.has_key('position'): position = kw['position'] del kw['position'] if kw.has_key('size'): size = kw['size'] del kw['size'] # wx.WANTS_CHARS says to give us e.g. TAB # wx.NO_FULL_REPAINT_ON_RESIZE cuts down resize flicker under GTK style = wx.WANTS_CHARS | wx.NO_FULL_REPAINT_ON_RESIZE if kw.has_key('style'): style = style | kw['style'] del kw['style'] # the enclosing frame must be shown under GTK or the windows # don't connect together properly if wx.Platform != '__WXMSW__': l = [] p = parent while p: # make a list of all parents l.append(p) p = p.GetParent() l.reverse() # sort list into descending order for p in l: p.Show(1) # code added by cpbotha to enable stereo correctly where the user # requests this; remember that the glXContext in this case is NOT # allocated by VTK, but by WX, hence all of this. if stereo and baseClass.__name__ == 'GLCanvas': # initialize GLCanvas with correct attriblist for stereo attribList = [ wx.glcanvas.WX_GL_RGBA, wx.glcanvas.WX_GL_MIN_RED, 1, wx.glcanvas.WX_GL_MIN_GREEN, 1, wx.glcanvas.WX_GL_MIN_BLUE, 1, wx.glcanvas.WX_GL_DEPTH_SIZE, 1, wx.glcanvas.WX_GL_DOUBLEBUFFER, wx.glcanvas.WX_GL_STEREO ] try: baseClass.__init__(self, parent, ID, position, size, style, attribList=attribList) except wx.PyAssertionError: # stereo visual couldn't be allocated, so we go back to default baseClass.__init__(self, parent, ID, position, size, style) # and make sure everyone knows about it stereo = 0 else: baseClass.__init__(self, parent, ID, position, size, style) # create the RenderWindow and initialize it self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(vtk.vtkRenderWindow()) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) try: self._Iren.GetRenderWindow().SetSize(size.width, size.height) except AttributeError: self._Iren.GetRenderWindow().SetSize(size[0], size[1]) if stereo: self._Iren.GetRenderWindow().StereoCapableWindowOn() self._Iren.GetRenderWindow().SetStereoTypeToCrystalEyes() self.__handle = None self._ActiveButton = 0 self.BindEvents() # with this, we can make sure that the reparenting logic in # Render() isn't called before the first OnPaint() has # successfully been run (and set up the VTK/WX display links) self.__has_painted = False # set when we have captured the mouse. self._own_mouse = False
def __init__(self, parent=None, wflags=Qt.WindowFlags(), **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if 'stereo' in kw: if kw['stereo']: stereo = 1 rw = None if 'rw' in kw: rw = kw['rw'] # create qt-level widget QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC) # check if retina display, or use 'retina' argument try: self.ratio = self.devicePixelRatio() except: self.ratio = 1 if 'retina' in kw: if kw['retina']: self.ratio = 2 if parent is None: self.ratio = 1 # to avoid strange boundary artefacts # if self.ratio > 1: # self.ratio *= 1.01 # unfortunately this causes problems with PNG writing if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if 'iren' in kw: self._Iren = kw['iren'] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed before # its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton self.__wheelDelta = 0 # do special handling of some keywords: # stereo, rw try: stereo = bool(kw['stereo']) except KeyError: stereo = False try: rw = kw['rw'] except KeyError: rw = None # create base qt-level widget if QVTKRWIBase == "QWidget": if "wflags" in kw: wflags = kw['wflags'] else: wflags = Qt.WindowFlags() QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC) elif QVTKRWIBase == "QGLWidget": QGLWidget.__init__(self, parent) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() # Python2 if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) # Python3 elif type(WId).__name__ == 'PyCapsule': from ctypes import pythonapi, c_void_p, py_object, c_char_p pythonapi.PyCapsule_GetName.restype = c_char_p pythonapi.PyCapsule_GetName.argtypes = [py_object] name = pythonapi.PyCapsule_GetName(WId) pythonapi.PyCapsule_GetPointer.restype = c_void_p pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p] WId = pythonapi.PyCapsule_GetPointer(WId, name) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() try: self._Iren = kw['iren'] except KeyError: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, wflags=Qt.WindowFlags(), **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton # do special handling of some keywords: # stereo, rw try: stereo = bool(kw['stereo']) except KeyError: stereo = False try: rw = kw['rw'] except KeyError: rw = None # create qt-level widget QWidget.__init__(self, parent, wflags|Qt.MSWindowsOwnDC) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() wid = self._get_win_id() self._RenderWindow.SetWindowInfo(wid) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() try: self._Iren = kw['iren'] except KeyError: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) # add wheel timer to fix scrolling issue with trackpad self.wheel_timer = QTimer() self.wheel_timer.setSingleShot(True) self.wheel_timer.setInterval(25) self.wheel_timer.timeout.connect(self._emit_wheel_event) self.wheel_accumulator = 0 self._saved_wheel_event_info = () self._Iren.AddObserver('CreateTimerEvent', messenger.send) messenger.connect(self._Iren, 'CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', messenger.send) messenger.connect(self._Iren, 'DestroyTimerEvent', self.DestroyTimer) self._RenderWindow.AddObserver('CursorChangedEvent', messenger.send) messenger.connect(self._RenderWindow, 'CursorChangedEvent', self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed # before its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, wflags=QtCore.Qt.WindowFlags(), **kw): # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget QtGui.QWidget.__init__(self, parent, wflags|QtCore.Qt.MSWindowsOwnDC) #QtOpenGL.QGLWidget.__init__(self, parent) if rw: # user-supplied render window # print MODULENAME, ' predefd rw' self._RenderWindow = rw else: # print MODULENAME, ' NOT predefd rw' self._RenderWindow = vtk.vtkRenderWindow() # print MODULENAME,' winSize = ',self._RenderWindow.GetSize() # ---- QVTKRenderWindowInteractor_mac.py: NOT predefd rw # ---- QVTKRenderWindowInteractor_mac.py: winSize = (0, 0) self._RenderWindow.SetWindowInfo(str(int(self.winId()))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) self._Iren.SetRenderWindow(self._RenderWindow) # self.interactorStyle=vtk.vtkInteractorStyleJoystickCamera() self.interactorStyle=vtk.vtkInteractorStyleSwitch() # self.interactorStyle.SetCurrentStyleToTrackballActor() self.interactorStyle.SetCurrentStyleToTrackballCamera() self._Iren.SetInteractorStyle(self.interactorStyle) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setAttribute(QtCore.Qt.WA_DeleteOnClose) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) self.mousePressEventFcn=self.mousePressEvent2DStyle
def __init__(self, parent=None, wflags=Qt.WindowFlags(), **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if 'stereo' in kw: if kw['stereo']: stereo = 1 rw = None if 'rw' in kw: rw = kw['rw'] # create qt-level widget QWidget.__init__(self, parent, wflags | Qt.MSWindowsOwnDC) # check if retina display, or use 'retina' argument try: self.ratio = self.devicePixelRatio() except: self.ratio = 1 if 'retina' in kw: if kw['retina']: self.ratio = 2 if parent is None: self.ratio = 1 # to avoid strange boundary artefacts # if self.ratio > 1: # self.ratio *= 1.01 # unfortunately this causes problems with PNG writing if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() WId = self.winId() if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) self._RenderWindow.SetWindowInfo(str(int(WId))) if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() if 'iren' in kw: self._Iren = kw['iren'] else: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed before # its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, **kw): logging.debug("In QVTKRenderWindowInteractor::__init__()") # the current button self._ActiveButton = QtCore.Qt.NoButton # private attributes self.__oldFocus = None self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = QtCore.Qt.NoModifier self.__saveButtons = QtCore.Qt.NoButton # do special handling of some keywords: # stereo, rw stereo = 0 if kw.has_key('stereo'): if kw['stereo']: stereo = 1 rw = None if kw.has_key('rw'): rw = kw['rw'] # create qt-level widget #QtGui.QWidget.__init__(self, parent) #QtOpenGL.QGLWidget.__init__(self, parent) super(QVTKRenderWindowInteractor, self).__init__(parent) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() if sys.platform == "win32": self._RenderWindow.SetWindowInfo(str(int(pythonapi.PyCObject_AsVoidPtr(self.winId())))) else: self._RenderWindow.SetWindowInfo(str(int(self.winId()))) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent) self.setAttribute(QtCore.Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(QtCore.Qt.WheelFocus) self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)) self._Timer = QtCore.QTimer(self) self.connect(self._Timer, QtCore.SIGNAL('timeout()'), self.TimerEvent) self._createTimerObserver = self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._destroyTimerObserver = self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._cursorObserver = self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent)
def __init__(self, parent=None, **kw): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton self.__wheelDelta = 0 # do special handling of some keywords: # stereo, rw try: stereo = bool(kw['stereo']) except KeyError: stereo = False try: rw = kw['rw'] except KeyError: rw = None # create qt-level widget if QVTKRWIBase == "QWidget": QWidget.__init__(self, parent) elif QVTKRWIBase == "QGLWidget": QGLWidget.__init__(self, parent) if rw: # user-supplied render window self._RenderWindow = rw else: self._RenderWindow = vtk.vtkRenderWindow() wid = self._get_win_id() self._RenderWindow.SetWindowInfo(wid) self._should_set_parent_info = (sys.platform == 'win32') if stereo: # stereo mode self._RenderWindow.StereoCapableWindowOn() self._RenderWindow.SetStereoTypeToCrystalEyes() try: self._Iren = kw['iren'] except KeyError: self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) # add wheel timer to fix scrolling issue with trackpad self.wheel_timer = None if PyQtImpl != 'PyQt5': self.wheel_timer = QTimer() self.wheel_timer.setSingleShot(True) self.wheel_timer.setInterval(25) self.wheel_timer.timeout.connect(self._emit_wheel_event) self._saved_wheel_event_info = () self._Iren.AddObserver('CreateTimerEvent', messenger.send) messenger.connect(self._Iren, 'CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', messenger.send) messenger.connect(self._Iren, 'DestroyTimerEvent', self.DestroyTimer) self._RenderWindow.AddObserver('CursorChangedEvent', messenger.send) messenger.connect(self._RenderWindow, 'CursorChangedEvent', self.CursorChangedEvent) # Create a hidden child widget and connect its destroyed signal to its # parent ``Finalize`` slot. The hidden children will be destroyed # before its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self, parent=None, wflags=Qt.WindowFlags()): # the current button self._ActiveButton = Qt.NoButton # private attributes self.__saveX = 0 self.__saveY = 0 self.__saveModifiers = Qt.NoModifier self.__saveButtons = Qt.NoButton # create qt-level widget glFormat = QtOpenGL.QGLFormat() glFormat.setAlpha(True) QtOpenGL.QGLWidget.__init__(self,glFormat,parent,None) # Create a wender window self._RenderWindow = vtk.vtkRenderWindow() self._RenderWindow.SetAlphaBitPlanes(1) self._RenderWindow.SetMultiSamples(0) # Create a renderer self._Renderer = vtk.vtkRenderer() self._Renderer.SetUseDepthPeeling(1) #self._Renderer.SetMaximumNumberOfPeels(100) #self._Renderer.SetOcclusionRatio(0.0) self._RenderWindow.AddRenderer(self._Renderer) WId = self.winId() # Python2 if type(WId).__name__ == 'PyCObject': from ctypes import pythonapi, c_void_p, py_object pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] WId = pythonapi.PyCObject_AsVoidPtr(WId) # Python3 elif type(WId).__name__ == 'PyCapsule': from ctypes import pythonapi, c_void_p, py_object, c_char_p pythonapi.PyCapsule_GetName.restype = c_char_p pythonapi.PyCapsule_GetName.argtypes = [py_object] name = pythonapi.PyCapsule_GetName(WId) pythonapi.PyCapsule_GetPointer.restype = c_void_p pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p] WId = pythonapi.PyCapsule_GetPointer(WId, name) self._RenderWindow.SetWindowInfo(str(int(WId))) self._Iren = vtk.vtkGenericRenderWindowInteractor() self._Iren.SetRenderWindow(self._RenderWindow) # do all the necessary qt setup self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_PaintOnScreen) self.setMouseTracking(True) # get all mouse events self.setFocusPolicy(Qt.WheelFocus) self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) self._Timer = QTimer(self) self._Timer.timeout.connect(self.TimerEvent) self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer) self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer) self._Iren.GetRenderWindow().AddObserver('CursorChangedEvent', self.CursorChangedEvent) #Create a hidden child widget and connect its destroyed signal to its #parent ``Finalize`` slot. The hidden children will be destroyed before #its parent thus allowing cleanup of VTK elements. self._hidden = QWidget(self) self._hidden.hide() self._hidden.destroyed.connect(self.Finalize)
def __init__(self): qDebug('RendererHelper::__init__()') super().__init__() self.__m_vtkFboItem = None self.gl = QOpenGLFunctions() self.__m_processingEngine: ProcessingEngine = None self.__m_selectedModel: Model = None self.__m_selectedActor: vtk.vtkActor = None self.__m_isModelSelected: bool = False self.__m_selectedModelPositionX: float = 0.0 self.__m_selectedModelPositionY: float = 0.0 self.__m_mouseLeftButton: QMouseEvent = None self.__m_mouseEvent: QMouseEvent = None self.__m_moveEvent: QMouseEvent = None self.__m_wheelEvent: QWheelEvent = None self.__m_platformModel: vtk.vtkCubeSource = None self.__m_platformGrid: vtk.vtkPolyData = None self.__m_platformModelActor: vtk.vtkActor = None self.__m_platformGridActor: vtk.vtkActor = None self.__m_platformWidth: float = 200.0 self.__m_platformDepth: float = 200.0 # self.__m_platformHeight:float = 200.0 self.__m_platformThickness: float = 2.0 self.__m_gridBottomHeight: float = 0.15 self.__m_gridSize: np.uint16 = 10 # self.__m_camPositionX:float = 0.0 # self.__m_camPositionY:float = 0.0 # self.__m_camPositionZ:float = 0.0 self.__m_clickPositionZ: float = 0.0 self.__m_firstRender: bool = True self.__m_modelsRepresentationOption: int = 0 self.__m_modelsOpacity: float = 1.0 self.__m_modelsGouraudInterpolation: bool = False #* Renderer #* https://vtk.org/doc/nightly/html/classQVTKOpenGLNativeWidget.html#details # QSurfaceFormat.setDefaultFormat(QVTKOpenGLNativeWidget.defaultFormat()) # from vtk 8.2.0 # QSurfaceFormat.setDefaultFormat(fmt) self.__m_vtkRenderWindow: vtk.vtkGenericOpenGLRenderWindow = vtk.vtkGenericOpenGLRenderWindow( ) self.__m_renderer: vtk.vtkRenderer = vtk.vtkRenderer() self.__m_vtkRenderWindow.AddRenderer(self.__m_renderer) #* Interactor self.__m_vtkRenderWindowInteractor: vtk.vtkGenericRenderWindowInteractor = vtk.vtkGenericRenderWindowInteractor( ) self.__m_vtkRenderWindowInteractor.EnableRenderOff() self.__m_vtkRenderWindow.SetInteractor( self.__m_vtkRenderWindowInteractor) #* Initialize the OpenGL context for the renderer self.__m_vtkRenderWindow.OpenGLInitContext() #* Interactor Style style = vtk.vtkInteractorStyleTrackballCamera() style.SetDefaultRenderer(self.__m_renderer) style.SetMotionFactor(10.0) self.__m_vtkRenderWindowInteractor.SetInteractorStyle(style) #* Picker self.__m_picker: vtk.vtkCellPicker = vtk.vtkCellPicker() self.__m_picker.SetTolerance(0.0)