def __init_vtk(self):
text_image_size = vtku.TextZero()
text_image_size.SetPosition(const.TEXT_POS_LEFT_UP)
text_image_size.SetValue("")
text_image_size.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_image_size = text_image_size
text_image_location = vtku.TextZero()
# text_image_location.SetVerticalJustificationToBottom()
text_image_location.SetPosition(const.TEXT_POS_LEFT_DOWN)
text_image_location.SetValue("")
text_image_location.bottom_pos = True
text_image_location.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_image_location = text_image_location
text_patient = vtku.TextZero()
# text_patient.SetJustificationToRight()
text_patient.SetPosition(const.TEXT_POS_RIGHT_UP)
text_patient.SetValue("")
text_patient.right_pos = True
text_patient.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_patient = text_patient
text_acquisition = vtku.TextZero()
# text_acquisition.SetJustificationToRight()
# text_acquisition.SetVerticalJustificationToBottom()
text_acquisition.SetPosition(const.TEXT_POS_RIGHT_DOWN)
text_acquisition.SetValue("")
text_acquisition.right_pos = True
text_acquisition.bottom_pos = True
text_acquisition.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_acquisition = text_acquisition
self.renderer = vtkRenderer()
self.renderer.SetLayer(0)
cam = self.renderer.GetActiveCamera()
self.canvas_renderer = vtkRenderer()
self.canvas_renderer.SetLayer(1)
self.canvas_renderer.SetActiveCamera(cam)
self.canvas_renderer.SetInteractive(0)
self.canvas_renderer.PreserveDepthBufferOn()
style = vtkInteractorStyleImage()
self.interactor.GetRenderWindow().SetNumberOfLayers(2)
self.interactor.GetRenderWindow().AddRenderer(self.renderer)
self.interactor.GetRenderWindow().AddRenderer(self.canvas_renderer)
self.interactor.SetInteractorStyle(style)
self.interactor.Render()
self.canvas = CanvasRendererCTX(self, self.renderer,
self.canvas_renderer)
self.canvas.draw_list.append(self.text_image_size)
self.canvas.draw_list.append(self.text_image_location)
self.canvas.draw_list.append(self.text_patient)
self.canvas.draw_list.append(self.text_acquisition)
def wxVTKRenderWindowConeExample():
"""Like it says, just a simple example.
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# every wx app needs an app
app = wx.App(False)
# create the widget
frame = wx.Frame(None, -1, "wxVTKRenderWindow", size=(400,400))
widget = wxVTKRenderWindow(frame, -1)
ren = vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the window
frame.Show()
app.MainLoop()
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 QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor class."""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# every QT app needs an app
app = QApplication(['QVTKRenderWindowInteractor'])
# create the widget
widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()
# if you don't want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
widget.show()
# start event processing
app.exec_()
def vtkRenderWidgetConeExample():
"""Like it says, just a simple example
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# create root window
root = tkinter.Tk()
# create vtkTkRenderWidget
pane = vtkTkRenderWidget(root,width=300,height=300)
ren = vtkRenderer()
pane.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# pack the pane into the tk root
pane.pack()
# start the tk mainloop
root.mainloop()
def toVTK(
assy: AssemblyProtocol,
renderer: vtkRenderer = vtkRenderer(),
loc: Location = Location(),
color: Tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
tolerance: float = 1e-3,
) -> vtkRenderer:
loc = loc * assy.loc
trans, rot = loc.toTuple()
if assy.color:
color = assy.color.toTuple()
if assy.shapes:
data = Compound.makeCompound(assy.shapes).toVtkPolyData(tolerance)
mapper = vtkMapper()
mapper.SetInputData(data)
actor = vtkActor()
actor.SetMapper(mapper)
actor.SetPosition(*trans)
actor.SetOrientation(*rot)
actor.GetProperty().SetColor(*color[:3])
actor.GetProperty().SetOpacity(color[3])
renderer.AddActor(actor)
for child in assy.children:
renderer = toVTK(child, renderer, loc, color, tolerance)
return renderer
def QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor class."""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# every QT app needs an app
app = QApplication(['QVTKRenderWindowInteractor'])
# create the widget
widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()
# if you don't want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
widget.show()
# start event processing
app.exec_()
def main():
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# load implementations for rendering and interaction factory classes
import vtkmodules.vtkRenderingOpenGL2
import vtkmodules.vtkInteractionStyle
# The main window
window = gtk.GtkWindow(gtk.WINDOW_TOPLEVEL)
window.set_title("A GtkVTKRenderWindow Demo!")
window.connect("destroy", gtk.mainquit)
window.connect("delete_event", gtk.mainquit)
window.set_border_width(10)
# A VBox into which widgets are packed.
vbox = gtk.GtkVBox(spacing=3)
window.add(vbox)
vbox.show()
# The GtkVTKRenderWindow
gvtk = GtkVTKRenderWindowInteractor()
#gvtk.SetDesiredUpdateRate(1000)
gvtk.set_usize(400, 400)
vbox.pack_start(gvtk)
gvtk.show()
gvtk.Initialize()
gvtk.Start()
# prevents 'q' from exiting the app.
gvtk.AddObserver("ExitEvent", lambda o, e, x=None: x)
# The VTK stuff.
cone = vtkConeSource()
cone.SetResolution(80)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#coneActor = vtkLODActor()
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(0.5, 0.5, 1.0)
ren = vtkRenderer()
gvtk.GetRenderWindow().AddRenderer(ren)
ren.AddActor(coneActor)
# A simple quit button
quit = gtk.GtkButton("Quit!")
quit.connect("clicked", gtk.mainquit)
vbox.pack_start(quit)
quit.show()
# show the main window and start event processing.
window.show()
gtk.mainloop()
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 wxVTKRenderWindowInteractorConeExample():
"""Like it says, just a simple example
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# load implementations for rendering and interaction factory classes
import vtkmodules.vtkRenderingOpenGL2
import vtkmodules.vtkInteractionStyle
# every wx app needs an app
app = wx.App(False)
# create the top-level frame, sizer and wxVTKRWI
frame = wx.Frame(None, -1, "wxVTKRenderWindowInteractor", size=(400, 400))
widget = wxVTKRenderWindowInteractor(frame, -1)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(widget, 1, wx.EXPAND)
frame.SetSizer(sizer)
frame.Layout()
# It would be more correct (API-wise) to call widget.Initialize() and
# widget.Start() here, but Initialize() calls RenderWindow.Render().
# That Render() call will get through before we can setup the
# RenderWindow() to render via the wxWidgets-created context; this
# causes flashing on some platforms and downright breaks things on
# other platforms. Instead, we call widget.Enable(). This means
# that the RWI::Initialized ivar is not set, but in THIS SPECIFIC CASE,
# that doesn't matter.
widget.Enable(1)
widget.AddObserver("ExitEvent", lambda o, e, f=frame: f.Close())
ren = vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the window
frame.Show()
app.MainLoop()
def initialize_vtk_widget(self):
"""
Initialize vtk widget for displaying 3D volume on PySide6
"""
# Create the renderer, the render window, and the interactor.
# The renderer draws into the render window,
# The interactor enables mouse and keyboard-based
# interaction with the scene.
self.vtk_widget = QVTKRenderWindowInteractor(self)
self.renderer = vtkRenderer()
self.iren = self.vtk_widget.GetRenderWindow().GetInteractor()
self.vtk_widget.GetRenderWindow().AddRenderer(self.renderer)
self.vtk_widget.GetRenderWindow().FullScreenOff()
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 main():
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# The main window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title("A GtkVTKRenderWindow Demo!")
window.connect("destroy", gtk.mainquit)
window.connect("delete_event", gtk.mainquit)
window.set_border_width(10)
# A VBox into which widgets are packed.
vbox = gtk.VBox(spacing=3)
window.add(vbox)
vbox.show()
# The GtkVTKRenderWindow
gvtk = GtkGLExtVTKRenderWindowInteractor()
#gvtk.SetDesiredUpdateRate(1000)
gvtk.set_size_request(400, 400)
vbox.pack_start(gvtk)
gvtk.show()
gvtk.Initialize()
gvtk.Start()
# prevents 'q' from exiting the app.
gvtk.AddObserver("ExitEvent", lambda o,e,x=None: x)
# The VTK stuff.
cone = vtkConeSource()
cone.SetResolution(80)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#coneActor = vtkLODActor()
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(0.5, 0.5, 1.0)
ren = vtkRenderer()
gvtk.GetRenderWindow().AddRenderer(ren)
ren.AddActor(coneActor)
# A simple quit button
quit = gtk.Button("Quit!")
quit.connect("clicked", gtk.mainquit)
vbox.pack_start(quit)
quit.show()
# show the main window and start event processing.
window.show()
gtk.mainloop()
def QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor class."""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# load implementations for rendering and interaction factory classes
import vtkmodules.vtkRenderingOpenGL2
import vtkmodules.vtkInteractionStyle
# every QT app needs an app
app = QApplication(['QVTKRenderWindowInteractor'])
window = QMainWindow()
# create the widget
widget = QVTKRenderWindowInteractor(window)
window.setCentralWidget(widget)
# if you don't want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
window.show()
widget.Initialize()
widget.Start()
# start event processing
# Source: https://doc.qt.io/qtforpython/porting_from2.html
# 'exec_' is deprecated and will be removed in the future.
# Use 'exec' instead.
try:
app.exec()
except AttributeError:
app.exec_()
def main():
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# load implementations for rendering and interaction factory classes
import vtkmodules.vtkRenderingOpenGL2
import vtkmodules.vtkInteractionStyle
# The main window
window = gtk.Window()
window.set_title("A GtkGLExtVTKRenderWindow Demo!")
window.connect("destroy", gtk.mainquit)
window.connect("delete_event", gtk.mainquit)
window.set_border_width(10)
vtkgtk = GtkGLExtVTKRenderWindow()
vtkgtk.show()
vbox = gtk.VBox(spacing=3)
vbox.show()
vbox.pack_start(vtkgtk)
button = gtk.Button('My Button')
button.show()
vbox.pack_start(button)
window.add(vbox)
window.set_size_request(400, 400)
# The VTK stuff.
cone = vtkConeSource()
cone.SetResolution(80)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#coneActor = vtkLODActor()
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(0.5, 0.5, 1.0)
ren = vtkRenderer()
vtkgtk.GetRenderWindow().AddRenderer(ren)
ren.AddActor(coneActor)
# show the main window and start event processing.
window.show()
gtk.mainloop()
def vtkRenderWindowInteractorConeExample():
"""Like it says, just a simple example
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# load implementations for rendering and interaction factory classes
import vtkmodules.vtkRenderingOpenGL2
import vtkmodules.vtkInteractionStyle
# create root window
root = tkinter.Tk()
# create vtkTkRenderWidget
pane = vtkTkRenderWindowInteractor(root, width=300, height=300)
pane.Initialize()
def quit(obj=root):
obj.quit()
pane.AddObserver("ExitEvent", lambda o, e, q=quit: q())
ren = vtkRenderer()
pane.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# pack the pane into the tk root
pane.pack(fill='both', expand=1)
pane.Start()
# start the tk mainloop
root.mainloop()
def vtkRenderWindowInteractorConeExample():
"""Like it says, just a simple example
https://gitlab.kitware.com/vtk/vtk/-/blob/master/Wrapping/Python/vtkmodules/tk/vtkTkRenderWindowInteractor.py
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
from vtkmodules.tk.vtkTkRenderWindowInteractor import vtkTkRenderWindowInteractor
# create root window
root = tkinter.Tk()
# create vtkTkRenderWidget
pane = vtkTkRenderWindowInteractor(root, width=300, height=300)
pane.Initialize()
def quit(obj=root):
obj.quit()
pane.AddObserver("ExitEvent", lambda o,e,q=quit: q())
ren = vtkRenderer()
pane.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# pack the pane into the tk root
pane.pack(fill='both', expand=1)
pane.Start()
# start the tk mainloop
root.mainloop()
def main():
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# The main window
window = gtk.Window()
window.set_title("A GtkGLExtVTKRenderWindow Demo!")
window.connect("destroy", gtk.mainquit)
window.connect("delete_event", gtk.mainquit)
window.set_border_width(10)
vtkgtk = GtkGLExtVTKRenderWindow()
vtkgtk.show()
vbox = gtk.VBox(spacing=3)
vbox.show()
vbox.pack_start(vtkgtk)
button = gtk.Button('My Button')
button.show()
vbox.pack_start(button)
window.add(vbox)
window.set_size_request(400, 400)
# The VTK stuff.
cone = vtkConeSource()
cone.SetResolution(80)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
#coneActor = vtkLODActor()
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.GetProperty().SetColor(0.5, 0.5, 1.0)
ren = vtkRenderer()
vtkgtk.GetRenderWindow().AddRenderer(ren)
ren.AddActor(coneActor)
# show the main window and start event processing.
window.show()
gtk.mainloop()
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 vtkRenderWindowInteractorConeExample():
"""Like it says, just a simple example
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
# create root window
root = tkinter.Tk()
# create vtkTkRenderWidget
pane = vtkTkRenderWindowInteractor(root, width=300, height=300)
pane.Initialize()
def quit(obj=root):
obj.quit()
pane.AddObserver("ExitEvent", lambda o,e,q=quit: q())
ren = vtkRenderer()
pane.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# pack the pane into the tk root
pane.pack(fill='both', expand=1)
pane.Start()
# start the tk mainloop
root.mainloop()
def __init__(self, *args, **kwargs):
super(PyView2D, self).__init__(*args, **kwargs)
self.block_signal = False
self.reader = vtkDICOMImageReader()
self.reader2 = vtkDICOMImageReader()
self.window = self.GetRenderWindow()
self.window.BordersOff(
) #attempt to remove imageactor borders, can remove
self.center = [0, 0, 0]
self.current_image = vtk.vtkImageData()
self.viewer_id = "default"
self.viewer_setup() # flexible for future
self.image_loaded = False
self.viewer_initialized = False
# self.read_image(image_path=None, orientation="axial") # flexible for future
self.window_level = vtkImageMapToWindowLevelColors()
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) #
### Wasil added ###
#QVTKRenderWindowInteractor relays Qt events to VTK
# self.frame = Qt.QFrame() # do i need this
# self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
# miu_viewer = PyView2D()
# vtkWidget has its own RenderWindow
# self.ren = vtk.vtkRenderer()
# or
# self.ren = miu_viewer.renderer # should have the actors already
# self.vtkWidget.GetRenderWindow().AddRenderer(self.renderer)
# self.vtkWidget.GetRenderWindow().SetSize(1000, 1000)
# miu_viewer.window.Render()
# or
# self.vtkWidget.GetRenderWindow().Render()
##########################
# have vtkRenderWindow
# add VTKrenderer
# self.window = vtkRenderWindow()
self.window.AddRenderer(self.renderer) #
# self.window.SetSize(1000, 1000)
self.window.SetSize(300, 300)
self.interactor_style = vtkInteractorStyleImage()
self.interactor_style.SetInteractionModeToImageSlicing()
# self.interactor = vtkRenderWindowInteractor() #
# self.iren is the interactor (also from RenderWindow)
self.interactor = self.GetRenderWindow().GetInteractor()
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()
### moved this down to after image is loaded
# 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 wxVTKRenderWindowInteractorConeExample():
"""Like it says, just a simple example
https://discourse.vtk.org/t/interactor-start-blocking-execution/1095/2
https://gitlab.kitware.com/vtk/vtk/-/blob/master/Wrapping/Python/vtkmodules/wx/wxVTKRenderWindowInteractor.py
ipython --gui=wx
#gui wx
run learn_vtk.py
"""
from vtkmodules.vtkFiltersSources import vtkConeSource
from vtkmodules.vtkRenderingCore import vtkActor, vtkPolyDataMapper, vtkRenderer
from vtkmodules.wx.wxVTKRenderWindowInteractor import wxVTKRenderWindowInteractor
import wx
colors = vtk.vtkNamedColors()
# every wx app needs an app
app = wx.App(False)
# create the top-level frame, sizer and wxVTKRWI
frame = wx.Frame(None, -1, "wxVTKRenderWindowInteractor", size=(400,400))
widget = wxVTKRenderWindowInteractor(frame, -1)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(widget, 1, wx.EXPAND)
frame.SetSizer(sizer)
frame.Layout()
# It would be more correct (API-wise) to call widget.Initialize() and
# widget.Start() here, but Initialize() calls RenderWindow.Render().
# That Render() call will get through before we can setup the
# RenderWindow() to render via the wxWidgets-created context; this
# causes flashing on some platforms and downright breaks things on
# other platforms. Instead, we call widget.Enable(). This means
# that the RWI::Initialized ivar is not set, but in THIS SPECIFIC CASE,
# that doesn't matter.
widget.Enable(1)
widget.AddObserver("ExitEvent", lambda o,e,f=frame: f.Close())
ren = vtkRenderer()
renwin = widget.GetRenderWindow()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtkConeSource()
cone.SetResolution(8)
coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the window
frame.Show()
# It works!
# wx.CallLater(1000*5, lambda : ren.SetBackground(colors.GetColor3d('Blue')))
# wx.CallLater(1000*8, lambda : renwin.Render())
# colors = vtk.vtkNamedColors()
# wx.CallAfter(lambda : ren.SetBackground(colors.GetColor3d('Blue')))
# wx.CallAfter(lambda : renwin.Render())
def fn():
ren.SetBackground(colors.GetColor3d('Blue'))
renwin.Render()
wx.CallLater(1000*3, fn)
#app.MainLoop() # comment out to interact in ipython
return app, ren, renwin
def __init_vtk(self):
text_image_size = vtku.TextZero()
text_image_size.SetPosition(const.TEXT_POS_LEFT_UP)
text_image_size.SetValue("")
text_image_size.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_image_size = text_image_size
text_image_location = vtku.TextZero()
# text_image_location.SetVerticalJustificationToBottom()
text_image_location.SetPosition(const.TEXT_POS_LEFT_DOWN)
text_image_location.SetValue("")
text_image_location.bottom_pos = True
text_image_location.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_image_location = text_image_location
text_patient = vtku.TextZero()
# text_patient.SetJustificationToRight()
text_patient.SetPosition(const.TEXT_POS_RIGHT_UP)
text_patient.SetValue("")
text_patient.right_pos = True
text_patient.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_patient = text_patient
text_acquisition = vtku.TextZero()
# text_acquisition.SetJustificationToRight()
# text_acquisition.SetVerticalJustificationToBottom()
text_acquisition.SetPosition(const.TEXT_POS_RIGHT_DOWN)
text_acquisition.SetValue("")
text_acquisition.right_pos = True
text_acquisition.bottom_pos = True
text_acquisition.SetSymbolicSize(wx.FONTSIZE_SMALL)
self.text_acquisition = text_acquisition
self.renderer = vtkRenderer()
self.renderer.SetLayer(0)
cam = self.renderer.GetActiveCamera()
self.canvas_renderer = vtkRenderer()
self.canvas_renderer.SetLayer(1)
self.canvas_renderer.SetActiveCamera(cam)
self.canvas_renderer.SetInteractive(0)
self.canvas_renderer.PreserveDepthBufferOn()
style = vtkInteractorStyleImage()
self.interactor = wxVTKRenderWindowInteractor(self.panel, -1,
size=wx.Size(340,340))
self.interactor.SetRenderWhenDisabled(True)
self.interactor.GetRenderWindow().SetNumberOfLayers(2)
self.interactor.GetRenderWindow().AddRenderer(self.renderer)
self.interactor.GetRenderWindow().AddRenderer(self.canvas_renderer)
self.interactor.SetInteractorStyle(style)
self.interactor.Render()
self.canvas = CanvasRendererCTX(self, self.renderer, self.canvas_renderer)
self.canvas.draw_list.append(self.text_image_size)
self.canvas.draw_list.append(self.text_image_location)
self.canvas.draw_list.append(self.text_patient)
self.canvas.draw_list.append(self.text_acquisition)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.interactor, 1, wx.GROW|wx.EXPAND)
sizer.Fit(self.panel)
self.panel.SetSizer(sizer)
self.Layout()
self.Update()
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
}
geom = vtkCompositeDataGeometryFilter()
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 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()
