def visualize(meshFname = None, dumpFname = None, nFrames = 100):
# Create a rendering window and renderer
transform = vtk.vtkTransform()
transform.Scale(10.0, 10.0, 10.0)
axes = vtk.vtkAxesActor()
axes.SetUserTransform(transform)
transform.Translate(2.0, -1.0, 0.0)
axes.SetUserTransform(transform)
renderer = vtk.vtkRenderer()
renderer.AddActor(axes)
camera = vtk.vtkCamera()
camera.SetFocalPoint(0, 0, 0);
renderer.SetActiveCamera(camera);
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
# Create a RenderWindowInteractor to permit manipulating the camera
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
scale = 0.1
if dumpFname is not None:
with open(dumFname) as fp:
lines = (line for line in fp if not line.strip()[:3].isalpha())
sphereData = np.array(lines)
Natoms = len(sphereData) - nFrames
for i in range(nFrames):
for data in sphereData[Natoms * nFrames: Natoms * (nFrames+1)]:
plotSpheres(ren, data[1] * scale, data[2] * scale, data[3] * scale, 0.001)
if meshFname is not None:
polydata = loadStl(meshFname)
renderer.AddActor(polyDataToActor(polydata))
renderer.SetBackground(0.1, 0.1, 0.1)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
renderer.ResetCamera()
iren.Initialize()
renWin.Render()
iren.Start()
def initVTKWidget(self,frame): """Sets up vtkWidget inside frame. Also sets up corresponding renderer and interactor. Args: frame (QtGui.QFrame): Parenting frame. Returns: tuple: Tuple containing: * vtkWidget (vtk.qt4.QVTKRenderWindowInteractor.QVTKRenderWindowInteractor): Qt vtk window interactor. * ren (vtk.vtkRenderer) * iren (vtk.vtkRenderWindowInteractor) """ vtkWidget = QVTKRenderWindowInteractor(frame) ren = vtk.vtkRenderer() vtkWidget.GetRenderWindow().AddRenderer(ren) iren = vtkWidget.GetRenderWindow().GetInteractor() iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) ren.ResetCamera() return vtkWidget, ren, iren
def __init__(self, parent):
super(pnt_interactor, self).__init__(parent)
self.ui = pt_main_window()
self.ui.setupUi(self)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
style.AutoAdjustCameraClippingRangeOn()
self.iren.SetInteractorStyle(style)
self.ren.GetActiveCamera().ParallelProjectionOn()
self.cp = self.ren.GetActiveCamera().GetPosition()
self.fp = self.ren.GetActiveCamera().GetFocalPoint()
self.iren.AddObserver("KeyPressEvent", self.keypress)
self.PointSize = 2
self.LineWidth = 1
self.Zaspect = 1.0
self.limits = np.empty(6)
self.picking = False
self.refWritten = False
self.floatWritten = False
self.ui.reloadButton.clicked.connect(
lambda: self.get_input_data(None, None))
self.ui.undoLastPickButton.clicked.connect(lambda: self.undo_pick())
self.ui.writeButton.clicked.connect(lambda: self.write_new())
self.ui.revertButton.clicked.connect(lambda: self.undo_revert())
self.ui.reduceButton.clicked.connect(lambda: self.reduce_pnts())
self.ui.showButton.clicked.connect(lambda: self.load_mat())
def __init__(self, parent=None, fix_camera=True,
background=None, size=None):
'''
fix_camera : more sensible default
'''
if parent is not None:
self.renWin = parent.GetRenderWindow()
self.iren = self.renWin.GetInteractor()
else:
self.renWin = vtk.vtkRenderWindow()
if size is None:
self.renWin.SetSize(800, 600)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.ren = vtk.vtkRenderer()
if background == 'white':
self.ren.SetBackground(1, 1, 1)
self.renWin.AddRenderer(self.ren)
if fix_camera:
camera = vtk.vtkInteractorStyleTrackballCamera()
camera.SetCurrentRenderer(self.ren)
self.iren.SetInteractorStyle(camera)
self.picker = vtk.vtkCellPicker()
self.iren.SetPicker(self.picker)
self.picker.AddObserver("EndPickEvent", self.handle_pick)
def setupInteractor(self,changeStyle=True): #Setup interactor self.iren = vtk.vtkTkRenderWindowInteractor() self.iren.SetRenderWindow(self.renWin) if changeStyle: style = vtk.vtkInteractorStyleTrackballCamera() self.iren.SetInteractorStyle(style)
def create_render_window(actors, callbacks, **kwargs):
""" Creates VTK render window with an interactor.
:param actors: list of VTK actors
:type actors: list, tuple
:param callbacks: callback functions for registering custom events
:type callbacks: dict
"""
# Get keyword arguments
figure_size = kwargs.get('figure_size', (800, 600))
camera_position = kwargs.get('camera_position', (0, 0, 100))
# Find camera focal point
center_points = []
for actor in actors:
center_points.append(actor.GetCenter())
camera_focal_point = linalg.vector_mean(*center_points)
# Create camera
camera = vtk.vtkCamera()
camera.SetPosition(*camera_position)
camera.SetFocalPoint(*camera_focal_point)
# Create renderer
renderer = vtk.vtkRenderer()
renderer.SetActiveCamera(camera)
renderer.SetBackground(1.0, 1.0, 1.0)
# Add actors to the scene
for actor in actors:
renderer.AddActor(actor)
# Render window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window.SetSize(*figure_size)
# Render window interactor
window_interactor = vtk.vtkRenderWindowInteractor()
window_interactor.SetRenderWindow(render_window)
# Add event observers
for cb in callbacks:
window_interactor.AddObserver(cb, callbacks[cb][0], callbacks[cb][1]) # cb name, cb function ref, cb priority
# Render actors
render_window.Render()
# Set window name after render() is called
render_window.SetWindowName("geomdl")
# Use trackball camera
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
window_interactor.SetInteractorStyle(interactor_style)
# Start interactor
window_interactor.Start()
# Return window interactor instance
return window_interactor
def SetInteractorStyle(self, state):
action = {
const.STATE_PAN: {
"MouseMoveEvent": self.OnPanMove,
"LeftButtonPressEvent": self.OnPanClick,
"LeftButtonReleaseEvent": self.OnReleasePanClick,
},
const.STATE_ZOOM: {
"MouseMoveEvent": self.OnZoomMove,
"LeftButtonPressEvent": self.OnZoomClick,
"LeftButtonReleaseEvent": self.OnReleaseZoomClick,
},
const.STATE_SPIN: {
"MouseMoveEvent": self.OnSpinMove,
"LeftButtonPressEvent": self.OnSpinClick,
"LeftButtonReleaseEvent": self.OnReleaseSpinClick,
},
const.STATE_WL: {
"MouseMoveEvent": self.OnWindowLevelMove,
"LeftButtonPressEvent": self.OnWindowLevelClick,
"LeftButtonReleaseEvent": self.OnWindowLevelRelease,
},
const.STATE_DEFAULT: {},
const.VOLUME_STATE_SEED: {"LeftButtonPressEvent": self.OnInsertSeed},
const.STATE_MEASURE_DISTANCE: {"LeftButtonPressEvent": self.OnInsertLinearMeasurePoint},
const.STATE_MEASURE_ANGLE: {"LeftButtonPressEvent": self.OnInsertAngularMeasurePoint},
}
if self._last_state in (const.STATE_MEASURE_DISTANCE, const.STATE_MEASURE_ANGLE):
if self.measures and not self.measures[-1].text_actor:
del self.measures[-1]
if state == const.STATE_WL:
self.on_wl = True
if self.raycasting_volume:
self.text.Show()
self.interactor.Render()
else:
self.on_wl = False
self.text.Hide()
self.interactor.Render()
if state in (const.STATE_MEASURE_DISTANCE, const.STATE_MEASURE_ANGLE):
self.interactor.SetPicker(self.measure_picker)
if state == const.STATE_ZOOM_SL:
style = vtk.vtkInteractorStyleRubberBandZoom()
self.interactor.SetInteractorStyle(style)
self.style = style
else:
style = vtk.vtkInteractorStyleTrackballCamera()
self.interactor.SetInteractorStyle(style)
self.style = style
# Check each event available for each mode
for event in action[state]:
# Bind event
style.AddObserver(event, action[state][event])
self._last_state = state
def show(ren, title="pvtk", size=(300, 300)):
""" Show window
Parameters
----------
ren: vtkRenderer() object
as returned from function ren().
title: string
a string for the window title bar.
size: (int, int)
(width, height) of the window.
"""
ren.ResetCameraClippingRange()
window = vtk.vtkRenderWindow()
window.AddRenderer(ren)
window.SetWindowName(title)
window.SetSize(size)
style = vtk.vtkInteractorStyleTrackballCamera()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(window)
iren.SetInteractorStyle(style)
iren.Initialize()
window.Render()
iren.Start()
def __init__(self, parent):
super(pnt_interactor,self).__init__(parent)
self.ui = pt_main_window()
self.ui.setupUi(self)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
style=vtk.vtkInteractorStyleTrackballCamera()
style.AutoAdjustCameraClippingRangeOn()
self.iren.SetInteractorStyle(style)
self.ren.GetActiveCamera().ParallelProjectionOn()
self.cp=self.ren.GetActiveCamera().GetPosition()
self.fp=self.ren.GetActiveCamera().GetFocalPoint()
self.iren.AddObserver("KeyPressEvent", self.keypress)
self.PointSize=2
self.LineWidth=1
self.Zaspect=1.0
self.limits=np.empty(6)
self.picking=False
self.refWritten = False
self.floatWritten = False
self.ui.reloadButton.clicked.connect(lambda: self.get_input_data(None,None))
self.ui.undoLastPickButton.clicked.connect(lambda: self.undo_pick())
self.ui.writeButton.clicked.connect(lambda: self.write_new())
self.ui.revertButton.clicked.connect(lambda: self.undo_revert())
self.ui.reduceButton.clicked.connect(lambda: self.reduce_pnts())
self.ui.levelButton.clicked.connect(lambda: self.level_pnts())
self.ui.rxButton_pos.clicked.connect(lambda: self.svd('x',False))
self.ui.ryButton_pos.clicked.connect(lambda: self.svd('y',False))
self.ui.rxButton_neg.clicked.connect(lambda: self.svd('x',True))
self.ui.ryButton_neg.clicked.connect(lambda: self.svd('y',True))
self.ui.showButton.clicked.connect(lambda: self.load_mat())
def __test_adjust_sphere():
import vtk
n_points = 4
points = []
for i in xrange(n_points):
p = np.random.random(3) * 100
points.append(p)
r, ctr = adjust_sphere(points)
r2 = r / 10
ren_win = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.SetRenderWindow(ren_win)
ren = vtk.vtkRenderer()
ren_win.AddRenderer(ren)
# draw points
for p in points:
__add_sphere_to_ren(p, r2, ren)
#draw big sphere
ac = __add_sphere_to_ren(ctr, r, ren)
ac.GetProperty().SetColor((1, 0, 0))
iren.Initialize()
iren.Start()
def StartInteractor(self):
if self.rendering == False:
print "Starting interactor"
self.renderer = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(self.renderer)
camera = self.renderer.GetActiveCamera()
camera.SetFocalPoint(0., 0., 0.)
camera.SetPosition(50., 0., 0.)
camera.Roll(-90)
mouse = vtk.vtkInteractorStyleTrackballCamera()
self.widget.SetInteractorStyle(mouse)
#create some axes to indicate the orientation of the galaxy
axes = vtk.vtkAxesActor()
self.axisw = vtk.vtkOrientationMarkerWidget()
self.axisw.SetOutlineColor(0.9300, 0.5700, 0.1300)
self.axisw.SetOrientationMarker(axes)
self.axisw.SetInteractor(self.widget._Iren)
self.axisw.SetViewport(0.0, 0.0, 0.3, 0.3)
self.axisw.SetEnabled(1)
self.axisw.InteractiveOn()
self.widget.GetRenderWindow().Render()
self.rendering = True
else:
print "Interactor has already started"
def __init__(self):
super(MyWindow, self).__init__()
os.chdir(functionPath)
uic.loadUi("registration_gui.ui", self)
os.chdir(startPath)
# Connect buttons to functions
# import moving data
self.ptcldMovingButton.clicked.connect(self.import_data)
# import fixed data
self.ptcldFixedButton.clicked.connect(self.import_data)
# execute qr_register function
self.registrationButton.clicked.connect(self.qf_register)
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.vtkFrame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.actor_moving = vtk.vtkActor()
self.moving_color = (0, 0.2)
self.actor_fixed = vtk.vtkActor()
self.fixed_color = (.8, 1)
self.ren.AddActor(self.actor_moving)
self.ren.AddActor(self.actor_fixed)
self.ren.ResetCamera()
self.vtkFrame.setLayout(self.vl)
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.show()
self.iren.Initialize()
def Start(self):
## create VTK interactor (this is the most important object)
# this need a Tkinter GUI object (render_frame) and a VTK render window (renWindow) to work
self.renWinInteractor = vtkTkRenderWindowInteractor(self.render_frame,
rw=self.renWindow,
width=600,
height=600)
self.renWinInteractor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera(
)) # set the trackball behaviour
# we can add additional configurations for this interactor here
axes = vtk.vtkAxesActor()
marker = vtk.vtkOrientationMarkerWidget()
marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(axes)
marker.SetInteractor(self.renWinInteractor)
marker.SetViewport(0.0, 0.0, 0.4, 0.4)
marker.SetEnabled(1)
marker.InteractiveOff()
## initialize the interactor and align it to the frame
self.renWinInteractor.Initialize()
self.renWinInteractor.pack(side='top', fill='both', expand=1)
self.renWindow.Render()
self.renWinInteractor.Start()
## main loop
self.root.mainloop()
def __init__(self, parent=None):
super(QtWidgets.QWidget, self).__init__(parent)
# Create a VTK widget and add it to the QFrame.
self.setLayout(QtWidgets.QVBoxLayout())
self.mVtkWidget = QVTKRenderWindowInteractor(self)
self.layout().addWidget(self.mVtkWidget)
self.layout().setContentsMargins(0, 0, 0, 0)
# Get the render window and set an interactor.
self.mRenderWindow = self.mVtkWidget.GetRenderWindow()
self.mInteractor = self.mRenderWindow.GetInteractor()
self.mInteractor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.mInteractor.Initialize()
# Create a new renderer and set the background color.
self.mRenderer = vtk.vtkRenderer()
self.setBackgroundColor([0.5, 0.5, 0.5])
self.mRenderWindow.AddRenderer(self.mRenderer)
self.mFpsObserver = FpsObserver.FpsObserver(self.mRenderer)
# Set the Vtk Window title.
self.mTitleActor = None
self.setTitle("pyVtkLib Demo")
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 run(self):
renderer = vtk.vtkRenderer()
renderer.SetBackground(0, 0, 0)
camera = vtk.vtkCamera()
camera.SetPosition((1, -1, -2))
camera.SetViewUp((0, -1, 0))
camera.SetFocalPoint((0, 0, 2))
renderer.SetActiveCamera(camera)
renwin = vtk.vtkRenderWindow()
renwin.SetWindowName("Point Cloud Viewer")
renwin.SetSize(800, 600)
renwin.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interstyle = vtk.vtkInteractorStyleTrackballCamera()
interactor.SetInteractorStyle(interstyle)
interactor.SetRenderWindow(renwin)
interactor.Initialize()
cb = vtkTimerCallback(self.cinematic, self.render_path,
self.clear_points)
cb.queue = self.queue
interactor.AddObserver('TimerEvent', cb.execute)
timerId = interactor.CreateRepeatingTimer(100)
#start the interaction and timer
interactor.Start()
def __init__(self, parent=None, title=None, shape=(1, 1), off_screen=None, **kwargs):
""" Initialize Qt interactor """
if not has_pyqt:
raise AssertionError('Requires PyQt5')
QVTKRenderWindowInteractor.__init__(self, parent)
BasePlotter.__init__(self, shape=shape, title=title)
self.parent = parent
# Create and start the interactive renderer
self.ren_win = self.GetRenderWindow()
for renderer in self.renderers:
self.ren_win.AddRenderer(renderer)
self.background_color = rcParams['background']
if self.title:
self.setWindowTitle(title)
if off_screen is None:
off_screen = pyvista.OFF_SCREEN
if off_screen:
self.ren_win.SetOffScreenRendering(1)
else:
self.iren = self.ren_win.GetInteractor()
self.iren.RemoveObservers('MouseMoveEvent') # slows window update?
# Enter trackball camera mode
istyle = vtk.vtkInteractorStyleTrackballCamera()
self.SetInteractorStyle(istyle)
self.add_axes()
self.iren.Initialize()
# QVTKRenderWindowInteractor doesn't have a "q" quit event
self.iren.AddObserver("KeyPressEvent", self.key_quit)
def __init__(
self,
threadLock,
actorWrapper_1,
axis=True,
):
self.threadLock = threadLock
self.ren = vtk.vtkRenderer()
self.transform = vtk.vtkTransform()
self.transform.Translate(0.0, 0.0, 0.0)
self.axesActor = vtk.vtkAxesActor()
self.axesActor.SetUserTransform(self.transform)
self.axesActor.AxisLabelsOff()
self.axesActor.SetTotalLength(1, 1, 1)
self.ren.AddActor(self.axesActor)
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
# pending in this case
self.ren.AddActor(actorWrapper_1.actor)
self.renWin.Render()
self.iren.Initialize()
self.style = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(self.style)
self.iren.AddObserver("TimerEvent", self.update_visualisation)
dt = 30 # ms -- fps
timer_id = self.iren.CreateRepeatingTimer(dt)
def Viewer(cloud):
"""
可视化点云及关键接触点，和公法线
:param cloud:点云
:return:
"""
obj = VTKObject()
obj.CreateFromArray(cloud[1].to_array())
obj.AddNormals(cloud[2].to_array()[0:, 0:3])
obj.SetupPipelineHedgeHog(10)
ren = vtk.vtkRenderer()
ren.AddActor(obj.GetActor())
obj2 = VTKObject()
obj2.CreateFromArray(cloud[0].to_array())
ren.AddActor(obj2.GetActor())
obj3 = VTKObject()
obj3.CreateFromArray(cloud[1].to_array())
obj3.GetActor().GetProperty().SetColor(1, 0, 0.0)
obj3.GetActor().GetProperty().SetPointSize(10)
ren.AddActor(obj3.GetActor())
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.Initialize()
iren.Start()
def __init__(self, background=(0.15, 0.15, 0.15), total_time_steps=None, timer_rate=60, gif_file=None):
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(background[0], background[1], background[2])
self.ren_win = vtk.vtkRenderWindow()
self.ren_win.AddRenderer(self.ren)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.ren_win)
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.actor_list = []
self.mapper_list = []
self.source_list = []
self.screenshot_count = 0
self.timer_rate = timer_rate
self.gif_data = []
if gif_file is not None:
try:
assert type(gif_file) is str
except AssertionError:
gif_file = str(gif_file)
self.gif_file = gif_file
else:
self.gif_file = None
if total_time_steps is not None:
assert type(total_time_steps) is int
self.timer_count = 0
self.total_time_steps = total_time_steps
def __init__(self, parent):
super(QMeshViewer, self).__init__(parent)
self.platformModel: vtk.vtkCubeSource = None
self.platformGrid: vtk.vtkPolyData = None
self.platformModelActor: vtk.vtkActor = None
self.platformGridActor: vtk.vtkActor = None
self.platformWidth: float = 200.0
self.platformDepth: float = 200.0
self.platformThickness: float = 2.0
self.gridBottomHeight: float = 0.15
self.gridSize: np.uint16 = 10
# Make the actual QtWidget a child so that it can be re_parented
self.interactor = QVTKRenderWindowInteractor(self)
self.layout = QtWidgets.QHBoxLayout()
self.layout.addWidget(self.interactor)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
self.initScene()
self.initPlatform()
self.initAxes()
self.resetCamera()
self.style = vtk.vtkInteractorStyleTrackballCamera()
self.style.SetDefaultRenderer(self.renderer)
self.interactor.SetInteractorStyle(self.style)
def example():
# Create the renderer
ren = vtk.vtkRenderer()
# Create the window
renWin = vtk.vtkRenderWindow()
# Add the renderer to the window
renWin.AddRenderer(ren)
# Define an interactor. This controls how the user can interact with
# things in the window.
iren = vtk.vtkRenderWindowInteractor()
# Set the window defined above as the window that the interactor
# will work on.
iren.SetRenderWindow(renWin)
# Define the axes actor.
axes = vtk.vtkAxesActor()
# Add the axes actor to the window.
ren.AddActor(axes)
# The default interactor style doesn't work well for a mouse,
# so we will redefine it as another pre-set style called 'track ball'.
trackBallStyle = vtk.vtkInteractorStyleTrackballCamera()
# Set the interactor style as the 'track ball' style defined above.
iren.SetInteractorStyle(trackBallStyle)
# This allows the interactor to initalize itself. It has to be
# called before an event loop.
iren.Initialize()
# Start the event loop.
iren.Start()
return
def __init__(self, ren=None, iren=None, filename="zxh-ape.obj", RESIZE = 1, COLOR = True, RADISU = 0.01, xl = 4, yl = 4, zl = 4):
# 参数初始化
self.ren = ren
self.iren = iren
self.filename = filename
self.RESIZE = RESIZE
self.RADISU = RADISU
self.COLOR = COLOR
self.xl = xl
self.yl = yl
self.zl = zl
# 设置背景颜色
self.ren.SetBackground(237, 237, 237)
# 用TrackballCamera的交互方式
InteractorStyle = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(InteractorStyle)
# 初始化画图
self.loadOBJ()
self.drawFace()
# 根据load进来的物体大小 自适应设置球体的半径大小
self.RADISU = (self.ffd.max_x - self.ffd.min_x) * self.RADISU
# 画点画线 增加监听器
self.drawControlPoints()
self.drawLines()
self.addControlPointsObserver()
def __test_normalize():
import vtk
ref_point = PointWithRef()
point2 = PointWithRef()
for p in (ref_point, point2):
p.point_pos = np.random.random(3) * 15 / 100
p.ref_pos = np.random.random(3) * 15 / 100
p.point_or = tuple(Quaternion.from_v_theta(np.random.random(3), np.random.random()).x)
p.ref_or = tuple(Quaternion.from_v_theta(np.random.random(3), np.random.random()).x)
ren_win = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.SetRenderWindow(ren_win)
ren = vtk.vtkRenderer()
ren_win.AddRenderer(ren)
# draw ref
__draw_point_and_uni(ref_point, (1, 1, 1), ren)
# draw original point
__draw_point_and_uni(point2, (0, 1, 0), ren)
#normalize
point2_n = normalize_point_to_ref(point2, ref_point)
__draw_point_and_uni(point2_n, (1, 0, 0), ren)
iren.Initialize()
iren.Start()
def __init__(self, h=800, w=600):
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(0.1, 0.1, 0.1)
# Add axes
axes = vtk.vtkAxesActor()
axes.GetXAxisCaptionActor2D().SetHeight(0.05)
axes.GetYAxisCaptionActor2D().SetHeight(0.05)
axes.GetZAxisCaptionActor2D().SetHeight(0.05)
axes.SetCylinderRadius(0.03)
axes.SetShaftTypeToCylinder()
self.renderer.AddActor(axes)
# Add render window
self.renwin = vtk.vtkRenderWindow()
self.renwin.SetWindowName("Point Cloud Viewer")
self.renwin.SetSize(h, w)
self.renwin.AddRenderer(self.renderer)
# An interactor
self.interactor = vtk.vtkRenderWindowInteractor()
interstyle = vtk.vtkInteractorStyleTrackballCamera()
self.interactor.SetInteractorStyle(interstyle)
self.interactor.SetRenderWindow(self.renwin)
self.camera_actors = []
def __init__(self, background_color=(0, 0, 0)):
"""
Main window of a BiorbdViz object. If one is interested in placing the main window inside another widget, they
should call VktWindow first, add whatever widgets/layouts they want in the 'VtkWindow.main_layout',
including, of course, the actual avatar from 'VtkWindow.vtkWidget'.
Parameters
----------
background_color : tuple(int)
Color of the background
"""
QtWidgets.QMainWindow.__init__(self)
self.frame = QtWidgets.QFrame()
self.setCentralWidget(self.frame)
self.ren = vtkRenderer()
self.ren.SetBackground(background_color)
self.avatar_widget = QVTKRenderWindowInteractor(self.frame)
self.avatar_widget.GetRenderWindow().SetSize(1000, 100)
self.avatar_widget.GetRenderWindow().AddRenderer(self.ren)
self.interactor = self.avatar_widget.GetRenderWindow().GetInteractor()
self.interactor.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.interactor.Initialize()
self.change_background_color(background_color)
self.main_layout = QtWidgets.QGridLayout()
self.main_layout.addWidget(self.avatar_widget)
self.frame.setLayout(self.main_layout)
self.show()
app._in_event_loop = True
self.is_active = True
self.should_reset_camera = False
app.processEvents()
def getVtkInteractor(self):
if (self.vtkInteractor == None):
self.vtkInteractor = kwvtk.vtkRenderWindowInteractor()
self.vtkInteractor.SetInteractorStyle(
kwvtk.vtkInteractorStyleTrackballCamera())
return self.vtkInteractor
def __init__(self):
self.outputs=[]
self.paint=rgbPainter()
self.scalingFactor=1.0
self.showAxes=True
self.showScalarBar=True
self.showCaption=True
self.showXYPlane=True
self.showYZPlane=True
self.showZXPlane=True
self.nbSize=80
self.sampleSpacing=8.0
self.camera = vtk.vtkCamera()
self.ren = vtk.vtkRenderer();
self.renWin = vtk.vtkRenderWindow();
self.renWin.AddRenderer(self.ren);
self.renWin.SetWindowName("DESICOS-viewer v0.1 ")
self.iren = vtk.vtkRenderWindowInteractor();
self.iren.SetRenderWindow(self.renWin);
style1 = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(style1)
self.ren.SetBackground(1, 1, 1);
self.renWin.SetSize(800, 600);
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):
"""
"""
# Symbol behaviour initialisation
self.draw_forward = ['F', 'B', 'G', 'R']
self.move_forward = ['M']
self.rotation = ['+', '-', '&', '^', '<', '>', '|']
self.push_pop = ['[', ']']
self.do_nothing = ['X']
# Init heap / stack to remember position
self.saved_pos = []
self.saved_vector = []
# VTK init
self.renWin = vtk.vtkRenderWindow()
self.renWin.SetSize(800, 600)
self.renWin.SetWindowName("L-System : " + self.lsystem.name + " ( " + self.viewer_type + " )")
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.style = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(self.style)
# Branch initial parameters
self.radius = self.lsystem.radius
self.length = self.lsystem.width
self.angle = self.lsystem.angle
def __init__(self, x, y):
self.height = y
self.width = x
self.cam = vtk.vtkInteractorStyleTrackballCamera()
self.renderer = vtk.vtkRenderer()
self.renderWindow = vtk.vtkRenderWindow()
self.interact = vtk.vtkRenderWindowInteractor()
def __init__(self, parent, id, style):
wx.Panel.__init__(self, parent, id, style=style)
self.renderer = vtk.vtkRenderer()
self.Interactor = wxVTKRenderWindowInteractor(self,
-1,
size=self.GetSize())
self.Interactor.GetRenderWindow().AddRenderer(self.renderer)
self.Interactor.Render()
istyle = vtk.vtkInteractorStyleTrackballCamera()
self.Interactor.SetInteractorStyle(istyle)
hbox = wx.BoxSizer(wx.VERTICAL)
hbox.Add(wx.StaticText(self, -1, 'Global Structure of Scaffold'))
hbox.Add(self.Interactor, 1, wx.EXPAND)
self.SetSizer(hbox)
self.init_actor()
self.add_axes()
self.draw_surface()
self.renderer.ResetCamera()
pub.subscribe(self._draw_surface, 'Recalculating surface')
pub.subscribe(self._calculate_porosity, 'Calculating porosity')
def __init__(self, renderer=None, parent=None):
# Every QT app needs a QApplication
self.app = QApplication.instance()
if self.app is None:
self.app = QApplication(sys.argv)
# Create the widget
if renderer is None:
self.renderer = vtk.vtkRenderer()
else:
self.renderer = renderer
self.widget = QVTKRenderWindowInteractor(parent)
self.widget.Initialize()
self.widget.Start()
# Set the interactor style
self.widget.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
# Get the render window from the widget
self.renderWindow = self.widget.GetRenderWindow()
self.renderWindow.AddRenderer(self.renderer)
# show the widget
self.widget.show()
def __init__(self, app: QApplication, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.app: QApplication = app
self.setupUi(self)
self.chooseFileBtt.pressed.connect(self.choose_file)
self.quitBtt.pressed.connect(self.close_app)
self.loadBtt.pressed.connect(self.load_btt)
self.deleteBtt.pressed.connect(self.del_btt)
self.vtk_widget = QVTKRenderWindowInteractor(self.widget)
self.vtk_widget.resize(self.widget.size())
self.renderer = vtk.vtkRenderer()
self.vtk_widget.GetRenderWindow().AddRenderer(self.renderer)
self.interactor = self.vtk_widget.GetRenderWindow().GetInteractor()
self.interactor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.interactor.Initialize()
self.renderer.GetActiveCamera().Elevation(-15)
self.renderer.ResetCamera()
self.model = QStandardItemModel()
self.model.itemChanged.connect(self.render_view)
self.listView.setModel(self.model)
self.listView.show()
self.threadpool = QThreadPool()
self.show()
def init_vtk_view(self):
# 在之前创建的view_widget上添加vtk控件
self.vtk_vertical_layout = QVBoxLayout(self.view_widget)
self.vtk_widget = QVTKRenderWindowInteractor(self.view_widget)
self.vtk_vertical_layout.addWidget(self.vtk_widget)
# 1.创建RenderWindow窗口
self.render_window = self.vtk_widget.GetRenderWindow()
# 2.创建render
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(1.0, 1.0, 1.0) # 设置页面底部颜色值
self.renderer.SetBackground2(0.1, 0.2, 0.4) # 设置页面顶部颜色值
self.renderer.SetGradientBackground(1) # 开启渐变色背景设置
self.render_window.AddRenderer(self.renderer)
self.render_window.Render()
# 3.设置交互方式
self.iren = self.render_window.GetInteractor() # 获取交互器
self.style = vtk.vtkInteractorStyleTrackballCamera(
) # 交互器样式的一种，该样式下，用户是通过控制相机对物体作旋转、放大、缩小等操作
# self.style = MyInteractor(self)
self.style.SetDefaultRenderer(self.renderer)
self.iren.SetInteractorStyle(self.style)
# 拾取器
cellPicker = vtk.vtkCellPicker()
self.iren.SetPicker(cellPicker)
# 4.添加坐标轴(加self,血的教训）
axesActor = vtk.vtkAxesActor()
self.axes_widget = vtk.vtkOrientationMarkerWidget()
self.axes_widget.SetOrientationMarker(axesActor)
self.axes_widget.SetInteractor(self.iren)
self.axes_widget.EnabledOn()
self.axes_widget.InteractiveOff() # 坐标系是否可移动
# 5.添加Actor
self.original_actor = vtk.vtkActor()
def main(pairs):
import __main__ as _main_module
renderer = vtk.vtkRenderer()
for op, file in pairs:
handler_name = g_op_map[op]
handler = _main_module.__dict__[handler_name]
fname = file
if not os.access(fname, os.R_OK):
print "Missing file %s" % (fname)
sys.exit(1)
else:
handler(fname, renderer)
show_axes(renderer)
# Create the usual rendering stuff.
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
renWin.SetSize(1000, 750)
iren = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# color
renderer.SetBackground(.1, .2, .4)
# Render the scene and start interaction.
iren.Initialize()
renWin.Render()
iren.Start()
def display(self):
r"""
Display the static mesh and the aligned within an interactive VTK
window
"""
if not hasattr(self.s, 'actor'):
self.s.addActor()
if not hasattr(self.m, 'actor'):
self.m.addActor()
# Generate a renderer window
win = vtkRenWin()
# Set the number of viewports
win.setnumViewports(1)
# Set the background colour
win.setBackground([1, 1, 1])
# Set camera projection
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(win)
renderWindowInteractor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
# Set camera projection
win.setView()
self.s.actor.setColor([1.0, 0.0, 0.0])
self.s.actor.setOpacity(0.5)
self.m.actor.setColor([0.0, 0.0, 1.0])
self.m.actor.setOpacity(0.5)
win.renderActors([self.s.actor, self.m.actor])
win.Render()
win.rens[0].GetActiveCamera().Azimuth(180)
win.rens[0].GetActiveCamera().SetParallelProjection(True)
win.Render()
return win
def updateContents(self, inputPorts):
if self.view==None:
self.view = pvsp.CreateRenderView()
renWin = self.view.GetRenderWindow()
self.SetRenderWindow(renWin)
iren = renWin.GetInteractor()
iren.SetNonInteractiveRenderDelay(0)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
del self.view.Representations[:]
# Fetch variables from the input port
(location, representations) = inputPorts
for rep in representations:
rep.set_view(self.view)
rep.execute()
# Set view specific properties
self.view.CenterAxesVisibility = 0
self.view.Background = [0.5, 0.5, 0.5]
self.view.ResetCamera()
self.view.StillRender()
QCellWidget.updateContents(self, inputPorts)
def visualize(self):
ugrid = self.ugrid
mapper = vtk.vtkDataSetMapper()
mapper.SetInputData(ugrid)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
rw = vtk.vtkRenderWindow()
rw.AddRenderer(renderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(rw)
renderer.AddActor(actor)
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(interactor_style)
lut = vtk.vtkLookupTable()
lut.SetHueRange(2 / 3, 0)
lut.Build()
mapper.SetLookupTable(lut)
# actor.GetProperty().SetRepresentationToWireframe()
iren.Initialize()
rw.Render()
iren.Start()
def initialize():
# Create a rendering window and renderer
transform = vtk.vtkTransform()
transform.Scale(10.0, 10.0, 10.0)
axes = vtk.vtkAxesActor()
axes.SetUserTransform(transform)
transform.Translate(3.0, -2.0, 0.0)
axes.SetUserTransform(transform)
ren = vtk.vtkRenderer()
ren.AddActor(axes)
ren.ResetCamera()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a RenderWindowInteractor to permit manipulating the camera
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
return ren, iren, renWin
def render(actors):
renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
interactor.SetRenderWindow(render_window)
actors.append(make_axis_actor())
for actor in actors:
actor.GetProperty().SetRepresentationToWireframe()
renderer.AddActor(actor)
renderer.SetBackground(0.1, 0.2, 0.4)
render_window.SetSize(800, 800)
interactor.Initialize()
renderer.ResetCamera()
renderer.GetActiveCamera().Zoom(1.5)
render_window.Render()
interactor.Start()
def DisplayVTKMesh(meshi,windowname):
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(meshi)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetInterpolationToPhong()
actor.GetProperty().SetAmbient(0.2)
actor.GetProperty().SetDiffuse(0.7)
actor.GetProperty().SetSpecular(0.6)
actor.GetProperty().SetSpecularPower(100)
actor.GetProperty().SetColor(0.8,0.8,1)
ren1 = vtk.vtkRenderer()
ren1.AddActor(actor)
ren1.SetBackground(0, 0, 0)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.SetSize(300, 300)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
iren.Initialize()
renWin.SetWindowName(windowname)
iren.Start()
def display(self):
r"""
Function to display the ampActor within in an interactable
vtkRenWin window
Returns
-------
win: vtkRenWin
The generated vtkRenWin
"""
if not hasattr(self, 'actor'):
self.addActor()
# Generate a renderer window
win = vtkRenWin()
# Set the number of viewports
win.setnumViewports(1)
# Set the background colour
win.setBackground([1, 1, 1])
# Set camera projection
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(win)
renderWindowInteractor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
# Set camera projection
win.setView()
win.renderActors([
self.actor,
])
win.Render()
win.rens[0].GetActiveCamera().Azimuth(0)
win.rens[0].GetActiveCamera().SetParallelProjection(True)
win.Render()
return win
def show(ren,title='Fos',size=(300,300)):
''' Show window
Parameters
----------
ren : vtkRenderer() object
as returned from function ren()
title : string
a string for the window title bar
size : (int, int)
(width,height) of the window
Examples
--------
>>> from dipy.viz import fos
>>> r=fos.ren()
>>> lines=[np.random.rand(10,3),np.random.rand(20,3)]
>>> colors=[0.2,0.8]
>>> c=fos.line(lines,colors)
>>> fos.add(r,c)
>>> l=fos.label(r)
>>> fos.add(r,l)
>>> fos.show(r)
'''
ren.ResetCamera()
window = vtk.vtkRenderWindow()
window.AddRenderer(ren)
window.SetWindowName(title)
window.SetSize(size)
style=vtk.vtkInteractorStyleTrackballCamera()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(window)
iren.SetInteractorStyle(style)
iren.Start()
def __init__(self,parent):
super(interactor, self).__init__(parent)
self.ui = main_window()
self.ui.setup(self)
self.ren = vtk.vtkRenderer()
colors = vtk.vtkNamedColors()
self.ren.SetBackground(colors.GetColor3d("aliceblue"))
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
style=vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(style)
self.iren.AddObserver("KeyPressEvent", self.keypress)
self.iren.AddObserver("MouseMoveEvent", self.on_mouse_move)
self.ren.GetActiveCamera().ParallelProjectionOn()
self.file = None #overwritten at launch
make_logo(self.ren)
self.ui.load_button.clicked.connect(self.load_vtu)
self.ui.mesh_display.clicked.connect(self.toggle_edges)
self.ui.clip_active_button.clicked.connect(self.clip)
self.ui.extract_button.clicked.connect(self.extract)
self.ui.export_line_button.clicked.connect(self.export_line)
self.ui.update_contours_button.clicked.connect(self.update_scale_bar)
self.ui.extract_boundaries_button.clicked.connect(self.get_boundaries)
def __init__(self, parent):
super(surf_int, self).__init__(parent)
self.ui = sf_main_window()
self.ui.setupUi(self)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.ren.GetActiveCamera().ParallelProjectionOn()
self.cp = self.ren.GetActiveCamera().GetPosition()
self.fp = self.ren.GetActiveCamera().GetFocalPoint()
self.iren.AddObserver("KeyPressEvent", self.keypress)
self.PointSize = 2
self.LineWidth = 1
self.Zaspect = 1.0
self.limits = np.empty(6)
self.picking = False
self.fitted = False
self.ui.updateButton.clicked.connect(lambda: self.onUpdateSpline())
self.ui.sectionButton.clicked.connect(lambda: self.Cut())
self.ui.revertButton.clicked.connect(lambda: self.RemoveCut())
self.ui.writeButton.clicked.connect(lambda: self.write())
self.ui.reloadButton.clicked.connect(lambda: self.get_input_data())
self.ui.undoLastPickButton.clicked.connect(lambda: self.undo_pick())
self.ui.numEdit1.valueChanged.connect(self.changeUpdateBackground)
self.ui.numEdit2.valueChanged.connect(self.changeUpdateBackground)
self.ui.numEdit3.valueChanged.connect(self.changeUpdateBackground)
self.ui.numEdit4.valueChanged.connect(self.changeUpdateBackground)
self.ui.drx.valueChanged.connect(self.changeUpdateBackground)
self.ui.dry.valueChanged.connect(self.changeUpdateBackground)
def __init__(self, threadLock, actorWrapper, axis=True,):
super(VTKVisualisation, self).__init__()
self.threadLock = threadLock
self.ren = vtk.vtkRenderer()
self.ren.AddActor(actorWrapper.actor)
self.axesActor = vtk.vtkAxesActor()
self.axesActor.AxisLabelsOff()
self.axesActor.SetTotalLength(1, 1, 1)
self.ren.AddActor(self.axesActor)
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
## IREN
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.iren.Initialize()
self.style = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(self.style)
self.iren.AddObserver("TimerEvent", self.update_visualisation)
dt = 30 # ms
timer_id = self.iren.CreateRepeatingTimer(dt)
def __init__(self):
"""Init."""
# Interactor responsible for moving the camera.
self.trackball_camera = vtk.vtkInteractorStyleTrackballCamera()
# Interactor responsible for moving/rotating a selected actor.
self.trackball_actor = vtk.vtkInteractorStyleTrackballActor()
# Interactor responsible for panning/zooming the camera.
self.image = vtk.vtkInteractorStyleImage()
# The picker allows us to know which object/actor is under the mouse.
self.picker = vtk.vtkPropPicker()
self.chosen_element = None
self.event = Event()
self.event2id = {} # To map an event's name to an ID.
# Define some interaction states
self.left_button_down = False
self.right_button_down = False
self.middle_button_down = False
self.active_props = set()
self.history = deque(maxlen=10) # Events history.
self.selected_props = {"left_button": set(),
"right_button": set(),
"middle_button": set()}
def __init__(self, parent: QWidget, geographic_bounds: dict, cities: list):
self.parent = parent
self.geographic_bounds = geographic_bounds
self.cities = cities
self.vtk_widget = QVTKRenderWindowInteractor(parent)
self.vtk_widget.resize(parent.size())
self.renderer = vtk.vtkRenderer()
self.vtk_widget.GetRenderWindow().AddRenderer(self.renderer)
self.interactor = self.vtk_widget.GetRenderWindow().GetInteractor()
self.interactor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.actors = {
'precipitation': [],
'clouds': [],
'wind': [],
'temperature': [],
'pressure': []
}
self.map_actor = None
self.legend_actors = {'temperature': [], 'pressure': []}
self.initialize_map()
self.initialize_legend()
self.interactor.Initialize()
self.renderer.GetActiveCamera().Elevation(-15)
self.renderer.ResetCamera()
def __init__(self, rwi, renderer):
# nnsmit-edit
self.overlay_active = 0;
# end edit
self.rwi = rwi
self.renderer = renderer
istyle = vtk.vtkInteractorStyleTrackballCamera()
rwi.SetInteractorStyle(istyle)
# we unbind the existing mousewheel handler so it doesn't
# interfere
rwi.Unbind(wx.EVT_MOUSEWHEEL)
rwi.Bind(wx.EVT_MOUSEWHEEL, self._handler_mousewheel)
self.ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut = self.ipws[0].GetLookupTable()
for ipw in self.ipws:
ipw.SetInteractor(rwi)
ipw.SetLookupTable(lut)
# nnsmit-edit
self.overlay_ipws = [vtk.vtkImagePlaneWidget() for _ in range(3)]
lut2 = self.overlay_ipws[0].GetLookupTable()
lut2.SetNumberOfTableValues(3)
lut2.SetTableValue(0,0,0,0,0)
lut2.SetTableValue(1,0.5,0,1,1)
lut2.SetTableValue(2,1,0,0,1)
lut2.Build()
for ipw_overlay in self.overlay_ipws:
ipw_overlay.SetInteractor(rwi)
ipw_overlay.SetLookupTable(lut2)
ipw_overlay.AddObserver('InteractionEvent', wx.EVT_MOUSEWHEEL)
# now actually connect the sync_overlay observer
for i,ipw in enumerate(self.ipws):
ipw.AddObserver('InteractionEvent',lambda vtk_o, vtk_e, i=i: self.observer_sync_overlay(self.ipws,i))
# end edit
# we only set the picker on the visible IPW, else the
# invisible IPWs block picking!
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.ipws[0].SetPicker(self.picker)
self.outline_source = vtk.vtkOutlineCornerFilter()
m = vtk.vtkPolyDataMapper()
m.SetInput(self.outline_source.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
a.PickableOff()
self.outline_actor = a
self.dv_orientation_widget = DVOrientationWidget(rwi)
# this can be used by clients to store the current world
# position
self.current_world_pos = (0,0,0)
self.current_index_pos = (0,0,0)
def PlotGrids_wFEM(grids):
""" Plots CFD structured grids with a single FEM """
N = len(grids)
HSV_tuples = [(x*1.0/N, 0.5, 0.5) for x in range(N)]
RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
actors = []
for i in range(len(grids)):
# Create mapper
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
mapper.SetInput(grids[i])
else:
mapper.SetInputData(grids[i])
# Create actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
if i != 0:
actor.GetProperty().SetRepresentationToWireframe()
actor.GetProperty().SetColor(RGB_tuples[i])
actor.GetProperty().LightingOff()
actors.append(actor)
# Add FEM Actor to renderer window
ren = vtk.vtkRenderer()
# ren.SetBackground(0.3, 0.3, 0.3)
ren.SetBackground(0.8, 0.8, 0.8)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
# Add actor
for actor in actors:
ren.AddActor(actor)
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
# widget.SetOutlineColor( 0.9300, 0.5700, 0.1300 )
widget.SetOrientationMarker( axes )
widget.SetInteractor( iren )
widget.SetViewport( 0.0, 0.0, 0.4, 0.4 )
widget.SetEnabled( 1 )
widget.InteractiveOn()
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def __init__(self):
self.renwin = vtk.vtkRenderWindow()
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.renwin.SetInteractor(self.iren)
self.ren = vtk.vtkRenderer()
self.renwin.AddRenderer(self.ren)
self.iren.Initialize()
def updateContents(self, inputPorts):
""" updateContents(inputPorts: tuple)
Updates the cell contents with new vtkRenderer
"""
renWin = self.GetRenderWindow()
for iHandler in self.iHandlers:
if iHandler.observer:
iHandler.observer.vtkInstance.SetInteractor(None)
iHandler.clear()
# Remove old renderers first
oldRenderers = self.getRendererList()
for renderer in oldRenderers:
renWin.RemoveRenderer(renderer)
renderer.SetRenderWindow(None)
del oldRenderers
(renderers, renderView, self.iHandlers, iStyle, picker) = inputPorts
if renderView:
renderView.vtkInstance.SetupRenderWindow(renWin)
renderers = [renderView.vtkInstance.GetRenderer()]
self.renderer_maps = {}
for renderer in renderers:
if renderView == None:
vtkInstance = renderer.vtkInstance
renWin.AddRenderer(vtkInstance)
self.renderer_maps[vtkInstance] = renderer.moduleInfo["moduleId"]
else:
vtkInstance = renderer
if hasattr(vtkInstance, "IsActiveCameraCreated"):
if not vtkInstance.IsActiveCameraCreated():
vtkInstance.ResetCamera()
else:
vtkInstance.ResetCameraClippingRange()
iren = renWin.GetInteractor()
if picker:
iren.SetPicker(picker.vtkInstance)
# Update interactor style
self.removeObserversFromInteractorStyle()
if renderView == None:
if iStyle == None:
iStyleInstance = vtk.vtkInteractorStyleTrackballCamera()
else:
iStyleInstance = iStyle.vtkInstance
iren.SetInteractorStyle(iStyleInstance)
self.addObserversToInteractorStyle()
for iHandler in self.iHandlers:
if iHandler.observer:
iHandler.observer.vtkInstance.SetInteractor(iren)
renWin.Render()
# Capture window into history for playback
# Call this at the end to capture the image after rendering
QCellWidget.updateContents(self, inputPorts)
def vtk_visualize(point_list, view_thresh):
point_cloud = VtkPointCloud()
x_thresh = view_thresh[0]
y_thresh = view_thresh[1]
z_thresh = view_thresh[2]
for i in range(len(point_list)):
point_coords = point_list[i]
if (point_coords[0] > x_thresh[0]) and (point_coords[0] < x_thresh[1]) and \
(point_coords[1] > y_thresh[0]) and (point_coords[1] < y_thresh[1]) and \
(point_coords[2] > z_thresh[0]) and (point_coords[2] < z_thresh[1]):
color_num = 0.7
else:
color_num = -1
point_cloud.addPoint(point_list[i], color_num)
# Add the velodyne plane
for x in np.linspace(-4, 4, 100):
for y in np.linspace(0, 2, 25):
tmp_coords = np.array([x, 0, y])
point_cloud.addPoint(tmp_coords, 1)
# Add the floor plane
plane_center = (-4, -4, -0.55)
normal = (0, 0, 1)
point1 = ([-4, 10, -0.55])
point2 = ([4, -4, -0.55])
point_cloud.addPlane(plane_center, normal, point1, point2)
# Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(point_cloud.point_vtkActor)
renderer.AddActor(point_cloud.plane_vtkActor)
renderer.SetBackground(0.0, 0.0, 0.0)
renderer.ResetCamera()
# Render Window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window_interactor.SetRenderWindow(render_window)
'''Add camera coordinates'''
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOutlineColor(0.9300, 0.5700, 0.1300)
widget.SetOrientationMarker(axes)
widget.SetInteractor(render_window_interactor)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
render_window.Render()
render_window_interactor.Start()
def __init__(self):
self.scene = Scene()
self.frame = MainWindow(self.scene)
self.camera_style = vtk.vtkInteractorStyleTrackballCamera()
self.camera_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.actor_style = vtk.vtkInteractorStyleTrackballActor()
self.actor_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.frame.iren.SetInteractorStyle(self.camera_style)
self.frame.iren.AddObserver('KeyPressEvent', self.keypress_handler)
self.frame.ren.SetBackground(name_to_rgb_float(MAIN_WIN_BG_COLOR))
self.scene.frame = self.frame
axes = vtk.vtkAxes()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(axes.GetOutputPort())
self.frame.axes_actor = vtk.vtkActor()
self.frame.axes_actor.SetMapper(mapper)
self.frame.axes_actor.GetProperty().SetLineWidth(1)
self.frame.axes_actor.SetVisibility(START_WITH_AXES)
self.frame.ren.AddActor(self.frame.axes_actor)
def setup_pipeline(self):
self.renderer = vtk.vtkRenderer()
self.render_window.AddRenderer(self.renderer)
self.interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.render_window.SetInteractor(self.interactor)
self.renderer.SetBackground(0.2,0.2,0.2)
camara = self.renderer.GetActiveCamera()
camara.SetPosition(0,1,0)
camara.SetFocalPoint(1,0,0)
camara.SetViewUp(0,0,-1)
def SetInteractor(self, iact):
self.delegate.SetInteractor(iact)
self.viewInteractorStyle = vtkInteractorStyleTrackballCamera()
iact.SetInteractorStyle(self.viewInteractorStyle)
self.leftClickObserverId = iact.AddObserver(
"LeftButtonPressEvent", self.HandleLeftClick
)
return
def __init__( self, parent, imode_callback, rmode_callback, ppos_callback, ao, **kwargs ):
# initialize Panel
if 'id' not in kwargs:
kwargs['id'] = wx.ID_ANY
wx.Panel.__init__( self, parent, **kwargs )
self.setInteractionMode = imode_callback
self.setInteractionMode(True)
self.recordingMode = False
self.setRecordingMode = rmode_callback
self.setRecordingMode(False)
self.setPickerPos = ppos_callback
self.ao = ao
self.aa = False
self.firstRender = True
self.vtkWidget = wxVTKRenderWindowInteractor(self, wx.ID_ANY)
self.iren = self.vtkWidget._Iren
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(0,0,0)
self.imageLayer = {}
self.CISID = -1 # Current Image Set ID
self.imageLayer[self.CISID] = IBCRenderer(self.renderer, self.iren.Render)
self.bacteriaLayer = BacteriaLayer(self.renderer, self.iren.Render)
self.viewCamActive = True
# for interactive clipping
self.planes = vtk.vtkPlanes()
self.ellipsoid = None
self.ellipsoidTextActor = None
# The SetInteractor method is how 3D widgets are associated with the
# render window interactor. Internally, SetInteractor sets up a bunch
# of callbacks using the Command/Observer mechanism (AddObserver()).
self.boxWidget = vtk.vtkBoxWidget()
self.boxWidget.SetInteractor(self.iren)
self.boxWidget.SetPlaceFactor(1.0)
# init vtk window
self.vtkWidget.Enable(1)
self.vtkWidget.AddObserver("ExitEvent", lambda o,e,f=parent: f.Close())
self.vtkWidget.GetRenderWindow().AddRenderer(self.renderer)
# Bind VTK events
self.iren.AddObserver("KeyPressEvent", self.OnKeyDown)
self.Sizer = wx.BoxSizer()
self.Sizer.Add(self.vtkWidget, 1, wx.EXPAND)
def __init__(self):
super(RenderWidget, self).__init__()
# Default volume renderer
self.renderer = vtkRenderer()
self.renderer.SetBackground2(0.4, 0.4, 0.4)
self.renderer.SetBackground(0.1, 0.1, 0.1)
self.renderer.SetGradientBackground(True)
self.renderer.SetLayer(0)
# Overlay renderer which is synced with the default renderer
self.rendererOverlay = vtkRenderer()
self.rendererOverlay.SetLayer(1)
self.rendererOverlay.SetInteractive(0)
self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras)
self.rwi = QVTKRenderWindowInteractor(parent=self)
self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
self.rwi.GetRenderWindow().AddRenderer(self.renderer)
self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay)
self.rwi.GetRenderWindow().SetNumberOfLayers(2)
self.rwi.SetDesiredUpdateRate(0)
self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)]
for index in range(3):
self.imagePlaneWidgets[index].DisplayTextOn()
self.imagePlaneWidgets[index].SetInteractor(self.rwi)
# Disable the margin for free rotation
self.imagePlaneWidgets[index].SetMarginSizeX(0.0)
self.imagePlaneWidgets[index].SetMarginSizeY(0.0)
self.mapper = vtkOpenGLGPUVolumeRayCastMapper()
self.mapper.SetAutoAdjustSampleDistances(1)
self.volume = None
self.imageData = None
self.VolumeVisualization = None
self.shouldResetCamera = False
self.gridItems = []
self.orientationGridItems = []
self.clippingBox = ClippingBox()
self.clippingBox.setWidget(self)
# Keep track of the base and user transforms
self.baseTransform = vtkTransform()
self.userTransform = vtkTransform()
self.setMinimumWidth(340)
self.setMinimumHeight(340)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.rwi, 0, 0)
self.setLayout(layout)
def PlotEdges(mesh, angle):
featureEdges = vtk.vtkFeatureEdges()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
featureEdges.SetInputData(mesh)
else:
featureEdges.SetInput(mesh)
featureEdges.FeatureEdgesOn()
featureEdges.BoundaryEdgesOff()
featureEdges.NonManifoldEdgesOff()
featureEdges.ManifoldEdgesOff()
featureEdges.SetFeatureAngle(angle)
edgeMapper = vtk.vtkPolyDataMapper();
edgeMapper.SetInputConnection(featureEdges.GetOutputPort());
edgeActor = vtk.vtkActor();
edgeActor.GetProperty().SetLineWidth(5);
edgeActor.SetMapper(edgeMapper)
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
mapper.SetInputData(mesh)
else:
mapper.SetInput(mesh)
# Actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().LightingOff()
###############################
# Display
###############################
# Render
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
ren.AddActor(actor)
ren.AddActor(edgeActor)
iren.Initialize()
renWin.Render()
iren.Start()