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