def main():
ren = vtkRenderer()
for item in glob.iglob(pattern, recursive=True):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(item)
reader.Update()
polydata = reader.GetOutput()
mapper = vtkPolyDataMapper()
mapper.SetInputData(polydata)
actor = vtkActor()
actor.SetMapper(mapper)
ren.AddActor(actor)
renWin = vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName('DDD')
iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renWin.Render()
iren.Start()
def main():
colors = vtkNamedColors()
renWin = vtkRenderWindow()
renWin.AddRenderer(renderer)
iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
earthCenter = [100.0, 0.0, 0.0]
earth = CreatePlanet(4.0, earthCenter)
marsCenter = [80.0, 0.0, 0.0]
mars = CreatePlanet(3.0, marsCenter)
sunCenter = [0.0, 0.0, 0.0]
sun = CreatePlanet(15.0, sunCenter)
earthActor = CreateVisualization(earth)
earthActor.GetProperty().SetColor(colors.GetColor3d('Blue'))
marsActor = CreateVisualization(mars)
marsActor.GetProperty().SetColor(colors.GetColor3d('Red'))
sunActor = CreateVisualization(sun)
sunActor.GetProperty().SetColor(colors.GetColor3d('Yellow'))
renderer.SetBackground(colors.GetColor3d('Black'))
renWin.SetSize(640, 480)
renWin.SetWindowName('Aarya\'s Solar System')
renWin.Render()
# Interact with the data.
iren.Start()
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 = 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 = 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 = 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 = 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 main():
colors = vtkNamedColors()
renderer = vtkRenderer()
renWin = vtkRenderWindow()
renWin.AddRenderer(renderer)
iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
sphere = vtkSphereSource()
sphere.SetPhiResolution(100)
sphere.SetThetaResolution(16)
sphere.SetCenter(2, 0, 0)
sphere.SetRadius(69)
sphere.Update()
sphereGeom = sphere.GetOutput()
cone = vtkConeSource()
cone.SetRadius(40)
cone.SetHeight(100)
cone.SetResolution(50)
cone.Update()
coneGeom = cone.GetOutput()
print('Number of points in sphere = ', sphereGeom.GetNumberOfPoints())
print('Number of triangles in sphere = ', sphereGeom.GetNumberOfCells())
print('Number of points in cone = ', coneGeom.GetNumberOfPoints())
print('Number of triangles in cone = ', coneGeom.GetNumberOfCells())
mapperS = vtkDataSetMapper()
mapperS.SetInputData(sphereGeom)
actorS = vtkActor()
actorS.SetMapper(mapperS)
actorS.GetProperty().SetColor(1.0, 0.0, 0.0)
actorS.GetProperty().SetOpacity(0.5)
renderer.AddActor(actorS)
mapperC = vtkDataSetMapper()
mapperC.SetInputData(coneGeom)
actorC = vtkActor()
actorC.SetMapper(mapperC)
actorC.GetProperty().SetOpacity(0.5)
renderer.AddActor(actorC)
renderer.SetBackground(colors.GetColor3d('SlateGray'))
renWin.SetSize(640, 480)
renWin.SetWindowName('Aarya\'s First VTK Program')
renWin.Render()
# Interact with the data.
iren.Start()
def _vtkRenderWindow(assy: AssemblyProtocol) -> vtkRenderWindow:
"""
Convert an assembly to a vtkRenderWindow. Used by vtk based exporters.
"""
renderer = vtkRenderer()
renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)
toVTK(assy, renderer)
renderer.ResetCamera()
renderer.SetBackground(1, 1, 1)
return renderWindow
def __init__(self, *args):
gtk.gtkgl.DrawingArea.__init__(self)
self.set_double_buffered(gtk.FALSE)
self._RenderWindow = vtkRenderWindow()
# private attributes
self.__Created = 0
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
self.ConnectSignals()
# need this to be able to handle key_press events.
self.set_flags(gtk.CAN_FOCUS)
# default size
self.set_size_request(300, 300)
def __init__(self, *args):
gtk.gtkgl.DrawingArea.__init__(self)
self.set_double_buffered(gtk.FALSE)
self._RenderWindow = vtkRenderWindow()
# private attributes
self.__Created = 0
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
self.ConnectSignals()
# need this to be able to handle key_press events.
self.set_flags(gtk.CAN_FOCUS)
# default size
self.set_size_request(300, 300)
def __init__(self, *args):
gtk.gtkgl.DrawingArea.__init__(self)
self.set_double_buffered(gtk.FALSE)
self._RenderWindow = vtkRenderWindow()
# private attributes
self.__Created = 0
self._ActiveButton = 0
self._Iren = 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 = vtkRenderWindow()
# private attributes
self.__Created = 0
self._ActiveButton = 0
self._Iren = 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):
l = list(args)
attr = (gtkgl.RGBA, gtkgl.DOUBLEBUFFER)
l.insert(0, self)
l.insert(1, attr)
apply(gtkgl.GtkGLArea.__init__, l)
self._RenderWindow = vtkRenderWindow()
# private attributes
self.__Created = 0
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
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 render_actors(actor_lst, bg_color='White'):
renderer = vtkRenderer()
renWin = vtkRenderWindow()
renWin.AddRenderer(renderer)
iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
for actor in actor_lst:
renderer.AddActor(actor)
colors = vtkNamedColors()
renderer.SetBackground(colors.GetColor3d(bg_color))
renderer.ResetCamera()
# renWin.SetSize(640, 480)
# Interact with the data.
renWin.Render()
iren.Start()
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
"""
# miscellaneous protected variables
self._CurrentRenderer = None
self._CurrentCamera = None
self._CurrentZoom = 1.0
self._CurrentLight = None
self._ViewportCenterX = 0
self._ViewportCenterY = 0
self._Picker = vtkCellPicker()
self._PickedActor = None
self._PickedProperty = vtkProperty()
self._PickedProperty.SetColor(1,0,0)
self._PrePickedProperty = None
# these record the previous mouse position
self._LastX = 0
self._LastY = 0
# the current interaction mode (Rotate, Pan, Zoom, etc)
self._Mode = None
self._ActiveButton = None
# private attributes
self.__OldFocus = None
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
# 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
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)
# initialize the wx.Window
if baseClass.__name__ == 'GLCanvas':
# Set the doublebuffer attribute of the GL canvas.
baseClass.__init__(self, parent, ID, pos=position, size=size,
style=style,
attribList=[wx.glcanvas.WX_GL_DOUBLEBUFFER])
else:
baseClass.__init__(self, parent, ID, pos=position, size=size,
style=style)
# create the RenderWindow and initialize it
self._RenderWindow = vtkRenderWindow()
self._RenderWindow.SetSize(size.width, size.height)
if stereo:
self._RenderWindow.StereoCapableWindowOn()
self._RenderWindow.SetStereoTypeToCrystalEyes()
self.__handle = None
# 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)
self.Bind(wx.EVT_MOTION, self.OnMotion)
self.Bind(wx.EVT_ENTER_WINDOW, self._OnEnterWindow)
self.Bind(wx.EVT_LEAVE_WINDOW, self._OnLeaveWindow)
self.Bind(wx.EVT_CHAR, self.OnChar)
# 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)
self.Bind(wx.EVT_MOVE, self.OnMove)
self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
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 = 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 = 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, 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
"""
# miscellaneous protected variables
self._CurrentRenderer = None
self._CurrentCamera = None
self._CurrentZoom = 1.0
self._CurrentLight = None
self._ViewportCenterX = 0
self._ViewportCenterY = 0
self._Picker = vtkCellPicker()
self._PickedActor = None
self._PickedProperty = vtkProperty()
self._PickedProperty.SetColor(1,0,0)
self._PrePickedProperty = None
# these record the previous mouse position
self._LastX = 0
self._LastY = 0
# the current interaction mode (Rotate, Pan, Zoom, etc)
self._Mode = None
self._ActiveButton = None
# private attributes
self.__OldFocus = None
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
# 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
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)
# initialize the wx.Window
if baseClass.__name__ == 'GLCanvas':
# Set the doublebuffer attribute of the GL canvas.
baseClass.__init__(self, parent, ID, pos=position, size=size,
style=style,
attribList=[wx.glcanvas.WX_GL_DOUBLEBUFFER])
else:
baseClass.__init__(self, parent, ID, pos=position, size=size,
style=style)
# create the RenderWindow and initialize it
self._RenderWindow = vtkRenderWindow()
self._RenderWindow.SetSize(size.width, size.height)
if stereo:
self._RenderWindow.StereoCapableWindowOn()
self._RenderWindow.SetStereoTypeToCrystalEyes()
self.__handle = None
# 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)
self.Bind(wx.EVT_MOTION, self.OnMotion)
self.Bind(wx.EVT_ENTER_WINDOW, self._OnEnterWindow)
self.Bind(wx.EVT_LEAVE_WINDOW, self._OnLeaveWindow)
self.Bind(wx.EVT_CHAR, self.OnChar)
# 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)
self.Bind(wx.EVT_MOVE, self.OnMove)
self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
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 = 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 = 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, 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 = 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._CurrentRenderer = None
self._CurrentCamera = None
self._CurrentZoom = 1.0
self._CurrentLight = None
self._ViewportCenterX = 0
self._ViewportCenterY = 0
self._Picker = vtkCellPicker()
self._PickedAssembly = None
self._PickedProperty = vtkProperty()
self._PickedProperty.SetColor(1,0,0)
self._PrePickedProperty = None
self._OldFocus = None
# used by the LOD actors
self._DesiredUpdateRate = 15
self._StillUpdateRate = 0.0001
# these record the previous mouse position
self._LastX = 0
self._LastY = 0
# private attributes
self.__InExpose = 0
# create the Tk bindings
self.BindTkRenderWidget()
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 = vtkGenericRenderWindowInteractor()
self._Iren.SetRenderWindow( 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
}
geom.SetInputConnection(interp.GetOutputPort())
# map them
mapper = vtkCompositePolyDataMapper()
mapper.SetInputConnection(geom.GetOutputPort())
mapper.SetScalarModeToUsePointFieldData()
mapper.SelectColorArray('point_poly')
mapper.SetScalarRange(1.0, 6.0)
mapper.InterpolateScalarsBeforeMappingOn()
mapper.SetScalarVisibility(1)
actor = vtkActor()
actor.SetMapper(mapper)
renderer = vtkRenderer()
renWin = vtkRenderWindow()
iren = vtkRenderWindowInteractor()
renderer.AddActor(actor)
renderer.SetBackground(0.0, 0.0, 0.0)
renWin.AddRenderer(renderer)
renWin.SetSize(300, 300)
iren.SetRenderWindow(renWin)
# ask for some specific data points
info = geom.GetOutputInformation(0)
geom.UpdateInformation()
time = 0.5
def GetRenderWindow(self):
addr = self.tk.call(self._w, 'GetRenderWindow')[5:]
return vtkRenderWindow('_%s_vtkRenderWindow_p' % addr)
def __init__(self):
VTK_DATA_ROOT = vtkGetDataRoot()
self.reader = vtkDICOMImageReader()
self.folder = "/Users/nandana/Downloads/image_ex"
self.reader.SetDirectoryName(self.folder)
self.reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter")
self.reader.SetDataExtent(0, 63, 0, 63, 1, 93)
self.reader.SetDataSpacing(3.2, 3.2, 1.5)
self.reader.SetDataOrigin(0.0, 0.0, 0.0)
self.reader.SetDataScalarTypeToUnsignedShort()
self.reader.UpdateWholeExtent()
self.reader.Update()
self.center = self.calculate_center()
self.axial = vtkMatrix4x4()
self.axial.DeepCopy((1, 0, 0, self.center[0], 0, 1, 0, self.center[1],
0, 0, 1, self.center[2], 0, 0, 0, 1))
self.coronal = vtkMatrix4x4()
self.coronal.DeepCopy(
(1, 0, 0, self.center[0], 0, 0, 1, self.center[1], 0, -1, 0,
self.center[2], 0, 0, 0, 1))
self.sagittal = vtkMatrix4x4()
self.sagittal.DeepCopy(
(0, 0, -1, self.center[0], 1, 0, 0, self.center[1], 0, -1, 0,
self.center[2], 0, 0, 0, 1))
self.oblique = vtkMatrix4x4()
self.oblique.DeepCopy(
(1, 0, 0, self.center[0], 0, 0.866025, -0.5, self.center[1], 0,
0.5, 0.866025, self.center[2], 0, 0, 0, 1))
self.img_reslice = vtkImageReslice()
self.roi_reslice = vtkImageReslice()
self.img_reslice.SetInputConnection(0, self.reader.GetOutputPort())
self.img_reslice.SetOutputDimensionality(2)
self.img_reslice.SetInterpolationModeToLinear()
self.roi_reslice.SetInputConnection(0, self.reader.GetOutputPort())
self.roi_reslice.SetOutputDimensionality(2)
self.roi_reslice.SetInterpolationModeToLinear()
self.set_orientation(self.axial)
self.img_table = vtkLookupTable()
self.roi_table = vtkLookupTable()
self.window_level = vtkImageMapToWindowLevelColors()
self.img_color = vtkImageMapToColors()
self.roi_color = vtkImageMapToColors()
self.img = self.map_img()
self.roi = self.map_roi()
self.px_coord_text_prop = vtkTextProperty()
self.px_coord_text_mapper = vtkTextMapper()
self.px_coord_text_actor = vtkActor2D()
self.world_coord_text_prop = vtkTextProperty()
self.world_coord_text_mapper = vtkTextMapper()
self.world_coord_text_actor = vtkActor2D()
self.usage_text_prop = vtkTextProperty()
self.usage_text_mapper = vtkTextMapper()
self.usage_text_actor = vtkActor2D()
self.renderer = vtkRenderer()
self.add_text()
self.renderer.AddActor(self.img)
self.renderer.AddActor(self.roi)
self.renderer.SetBackground(0.2, 0.3, 0.4)
self.window = vtkRenderWindow()
self.window.AddRenderer(self.renderer)
self.window.SetSize(1000, 1000)
self.interactor_style = vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImageSlicing()
self.interactor = vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactor_style)
self.window.SetInteractor(self.interactor)
self.window_level.SetWindow(1000)
self.window_level.SetLevel(200)
self.window_level.Update()
self.window.Render()
self.interactor_style.AddObserver("MouseWheelForwardEvent",
self.scroll_forward_callback)
self.interactor_style.AddObserver("MouseWheelBackwardEvent",
self.scroll_backward_callback)
self.interactor_style.AddObserver("MouseMoveEvent",
self.mouse_move_callback)
self.interactor_style.AddObserver("KeyPressEvent",
self.key_press_callback)
self.interactor_style.AddObserver("LeftButtonPressEvent",
self.left_press_callback)
self.window.AddObserver("ModifiedEvent", self.window_mod_callback)
self.actions = {
"Slicing": 0,
"Cursor": 0,
"CurrentPos": -1,
"LastPos": -1,
"DoubleClick": 0
}
def main():
colors = vtkNamedColors()
operation = "intersection"
reader = vtkUnstructuredGridReader()
reader.SetFileName(ATRIA_VTK_FILE)
geo_filter = vtkGeometryFilter()
geo_filter.SetInputConnection(reader.GetOutputPort())
geo_filter.Update()
poly1 = geo_filter.GetOutput()
tri1 = vtkTriangleFilter()
tri1.SetInputData(poly1)
clean1 = vtkCleanPolyData()
clean1.SetInputConnection(tri1.GetOutputPort())
clean1.Update()
input1 = clean1.GetOutput()
sphereSource1 = vtkSphereSource()
sphereSource1.SetCenter(20.43808060942321, 18.333007878470767,
34.5753857481471)
sphereSource1.SetRadius(0.5)
# sphereSource1.SetPhiResolution(21)
# sphereSource1.SetThetaResolution(21)
sphereSource1.Update()
input2 = sphereSource1.GetOutput()
input1Mapper = vtkPolyDataMapper()
input1Mapper.SetInputData(input1)
input1Mapper.ScalarVisibilityOff()
input1Actor = vtkActor()
input1Actor.SetMapper(input1Mapper)
input1Actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Tomato"))
input1Actor.GetProperty().SetSpecular(0.6)
input1Actor.GetProperty().SetSpecularPower(20)
# input1Actor.SetPosition(input1.GetBounds()[1] - input1.GetBounds()[0], 0, 0)
input2Mapper = vtkPolyDataMapper()
input2Mapper.SetInputData(input2)
input2Mapper.ScalarVisibilityOff()
input2Actor = vtkActor()
input2Actor.SetMapper(input2Mapper)
input2Actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Mint"))
input2Actor.GetProperty().SetSpecular(0.6)
input2Actor.GetProperty().SetSpecularPower(20)
# input2Actor.SetPosition(-(input1.GetBounds()[1] - input1.GetBounds()[0]), 0, 0)
booleanOperation = vtkBooleanOperationPolyDataFilter()
if operation.lower() == "union":
booleanOperation.SetOperationToUnion()
elif operation.lower() == "intersection":
booleanOperation.SetOperationToIntersection()
elif operation.lower() == "difference":
booleanOperation.SetOperationToDifference()
else:
print("Unknown operation:", operation)
return
booleanOperation.SetInputData(0, input1)
booleanOperation.SetInputData(1, input2)
booleanOperationMapper = vtkPolyDataMapper()
booleanOperationMapper.SetInputConnection(booleanOperation.GetOutputPort())
booleanOperationMapper.ScalarVisibilityOff()
booleanOperationActor = vtkActor()
booleanOperationActor.SetMapper(booleanOperationMapper)
booleanOperationActor.GetProperty().SetDiffuseColor(
colors.GetColor3d("Banana"))
booleanOperationActor.GetProperty().SetSpecular(0.6)
booleanOperationActor.GetProperty().SetSpecularPower(20)
renderer = vtkRenderer()
renderer.AddViewProp(input1Actor)
renderer.AddViewProp(input2Actor)
renderer.AddViewProp(booleanOperationActor)
renderer.SetBackground(colors.GetColor3d("Silver"))
renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
renderWindow.SetWindowName("BooleanOperationPolyDataFilter")
viewUp = [0.0, 0.0, 1.0]
position = [0.0, -1.0, 0.0]
PositionCamera(renderer, viewUp, position)
renderer.GetActiveCamera().Dolly(1.4)
renderer.ResetCameraClippingRange()
renWinInteractor = vtkRenderWindowInteractor()
renWinInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renWinInteractor.Start()
def GetRenderWindow(self):
addr = self.tk.call(self._w, 'GetRenderWindow')[5:]
return vtkRenderWindow('_%s_vtkRenderWindow_p' % addr)
usageTextActor = vtkActor2D() usageTextActor.SetMapper(usageTextMapper) usageTextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() usageTextActor.GetPositionCoordinate().SetValue(0.05, 0.95) renderer = vtkRenderer() renderer.AddActor(original) renderer.AddActor(actor) renderer.AddActor2D(coordTextActor) renderer.AddActor2D(usageTextActor) renderer.AddActor2D(worldCoordTextActor) renderer.SetBackground(0.2, 0.3, 0.4) window = vtkRenderWindow() window.AddRenderer(renderer) window.SetSize(1000, 1000) # Set up the interaction interactorStyle = vtkInteractorStyleImage() interactorStyle.SetInteractionModeToImageSlicing() interactor = vtkRenderWindowInteractor() interactor.SetInteractorStyle(interactorStyle) window.SetInteractor(interactor) windowLevel.SetWindow(1000) windowLevel.SetLevel(200) windowLevel.Update()
def __init__(self, parent=None, **kw):
# the current button
self._ActiveButton = MouseButton.NoButton
# private attributes
self.__saveX = 0
self.__saveY = 0
self.__saveModifiers = KeyboardModifier.NoModifier
self.__saveButtons = MouseButton.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 = WindowType.Widget # what Qt.WindowFlags() returns (0)
QWidget.__init__(self, parent, wflags | WindowType.MSWindowsOwnDC)
elif QVTKRWIBase == "QGLWidget":
QGLWidget.__init__(self, parent)
elif QVTKRWIBase == "QOpenGLWidget":
QOpenGLWidget.__init__(self, parent)
if rw: # user-supplied render window
self._RenderWindow = rw
else:
self._RenderWindow = 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 = vtkGenericRenderWindowInteractor()
self._Iren.SetRenderWindow(self._RenderWindow)
# do all the necessary qt setup
self.setAttribute(WidgetAttribute.WA_OpaquePaintEvent)
self.setAttribute(WidgetAttribute.WA_PaintOnScreen)
self.setMouseTracking(True) # get all mouse events
self.setFocusPolicy(FocusPolicy.WheelFocus)
self.setSizePolicy(
QSizePolicy(SizePolicy.Expanding, SizePolicy.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)
# If we've a parent, it does not close the child when closed.
# Connect the parent's destroyed signal to this widget's close
# slot for proper cleanup of VTK objects.
if self.parent():
self.parent().destroyed.connect(self.close,
ConnectionType.DirectConnection)
