def __init__(self, gfx, frame):
self.renderer = vtk.vtkOpenGLRenderer()
self.renwin = vtk.vtkXOpenGLRenderWindow()
self.renwin.AddRenderer(self.renderer)
self.renwin.SetStereoTypeToAnaglyph()
self.iren = vtkTkRenderWindowInteractor(frame,
rw=self.renwin,
width=500,
height=500)
self.istyle = vtk.vtkInteractorStyleSwitch()
self.iren.SetInteractorStyle(self.istyle)
self.istyle.SetCurrentStyleToTrackballCamera()
self.iren.Initialize()
self.iren.pack(side='bottom', fill='both', expand=0)
self.iren.Start()
self.camera = vtk.vtkCamera()
self.camera.SetFocalPoint(0, 0, 0)
self.camera.SetPosition(0, 0, 250)
self.camera.SetViewUp(0, 0, 0)
self.camera.SetEyeAngle(5.0)
self.tm = None
self.renderer.SetActiveCamera(self.camera)
self.renwin.Render()
self.currentmod = None
self.nbstep = None
self.oldon = None
self.tloop = None
self.tloopobs = None
self.gfx = gfx
def InitRenderWindow(self,
stereo_on=False,
axes_on=False,
bkgnd=[0.8, 0.8, 0.8],
res_x=600,
res_y=600):
"""Sets up the visualisation environment"""
self.renderer = vtk.vtkOpenGLRenderer()
self.renderWindow = vtk.vtkRenderWindow()
self.renderWindow.SetStereoCapableWindow(stereo_on)
self.renderWindow.SetStereoRender(stereo_on)
self.renderWindow.SetStereoTypeToSplitViewportHorizontal()
self.renderWindow.AddRenderer(self.renderer)
self.renderWindow.SetMultiSamples(0)
self.renderWindow.SetAlphaBitPlanes(1)
self.renderer.SetBackground(bkgnd)
self.renderWindow.SetSize(res_x, res_y)
self.renderer.ResetCamera()
self.renderer.GetActiveCamera().Zoom(1)
self.InitRenderPasses()
axes = vtk.vtkAxesActor()
axes.SetConeRadius(0.15)
axes.AxisLabelsOn()
if axes_on:
self.renderer.AddActor(axes)
self.camera = self.renderer.GetActiveCamera()
self.windowFilter = vtk.vtkWindowToImageFilter()
self.windowFilter.SetInput(self.renderWindow)
self.windowFilter.ReadFrontBufferOff()
self.writer = vtk.vtkJPEGWriter()
self.writer.SetInputConnection(self.windowFilter.GetOutputPort())
def setenv(self, root):
self.renderer = vtk.vtkOpenGLRenderer()
#self.renderer.SetBackground(1,1,1)
self.renwin = vtk.vtkXOpenGLRenderWindow()
self.renwin.AddRenderer(self.renderer)
#self.renwin.SetStereoTypeToRedBlue()
#self.renwin.StereoCapableWindowOn()
#self.renwin.SetStereoTypeToCrystalEyes()
#self.renwin.StereoRenderOn() #activer la stereoscopie
self.renwin.SetStereoTypeToAnaglyph()
#self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1
self.iren = vtkTkRenderWindowInteractor(root,
rw=self.renwin,
width=1000,
height=800)
self.istyle = vtk.vtkInteractorStyleSwitch()
self.iren.SetInteractorStyle(self.istyle)
self.istyle.SetCurrentStyleToTrackballCamera()
self.iren.Initialize()
self.iren.pack(side='top', fill='both', expand=1)
self.addobservers()
self.setcam()
self.setaxes()
#self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog
self.iren.Start()
self.display_ascii_logo()
def __init__(self):
super().__init__()
# WIDGET
self._widget = QWidget(self)
self._widget.setAttribute(Qt.WA_TranslucentBackground)
self.setCentralWidget(self._widget)
self.resize(900, 900)
self._widget.event = types.MethodType(self._handle_event, self._widget)
self._widget.setAttribute(Qt.WA_AcceptTouchEvents) # 与半透明分开设置
# VTK
self._vtk_widget = QVTKRenderWindowInteractor(self._widget)
self._vtk_widget.resize(900, 900)
self._ren_win = self._vtk_widget.GetRenderWindow()
self._ren_win.GetInteractor().SetInteractorStyle(
vtk.vtkInteractorStyleMultiTouchCamera())
self._renderer = vtk.vtkOpenGLRenderer()
self._renderer.SetBackground((0, 0, 0))
self._renderer.AddActor(self._axis_actor())
self._ren_win.AddRenderer(self._renderer)
self._vtk_widget.Start()
# BUTTON WIDGET
widget = QWidget(self._widget)
widget.resize(200, 200)
widget.setStyleSheet('QWidget {background: red}')
widget.setToolTip('button test')
widget.show()
button = QPushButton(widget)
button.setStyleSheet('QPushButton {background: blue}')
button.setText('test')
button.clicked.connect(lambda: print('clicked'))
button.show()
def __init__(self):
super().__init__()
signal.signal(signal.SIGINT, self.exit)
# WIDGET
self._widget = QWidget(self)
self.setCentralWidget(self._widget)
self.resize(900, 900)
self._widget.event = types.MethodType(self._handle_event, self._widget)
self._widget.setAttribute(Qt.WA_AcceptTouchEvents
| Qt.WA_TranslucentBackground)
self._widget.setWindowFlags(Qt.NoDropShadowWindowHint)
# VTK
self._vtk_widget = QVTKRenderWindowInteractor(self._widget)
self._vtk_widget.resize(900, 900)
self._ren_win = self._vtk_widget.GetRenderWindow()
self._interactor = self._ren_win.GetInteractor()
self._vtk_widget.SetInteractorStyle(InteractorStyle())
# # TEST_WIDGET
self._test_widget = QWidget(self)
self._test_widget.resize(300, 300)
self._test_widget.setStyleSheet(
'QWidget {background: rgb(60, 60, 60)}')
# TEST_BTN
self._button = QPushButton(self._test_widget)
self._button.setText('test')
self._button.setStyleSheet(
'QPushButton {background: rgb(255, 255, 255)}')
self._button.pressed.connect(self._pressed)
self._button.released.connect(self._released)
self._button.resize(100, 30)
self._button.move(100, 200)
self._test_widget1 = QToolBox(self._test_widget)
self._test_widget1.resize(100, 100)
self._test_widget1.show()
self._button.show()
self._test_widget.show()
# RENDER
self._renderer = vtk.vtkOpenGLRenderer()
self._renderer.SetBackground((0, 0, 0))
self._renderer.AddActor(self._axis_actor())
for actor in self._stl_actor().values():
self._renderer.AddActor(actor)
self._camera = self._renderer.GetActiveCamera()
self._ren_win.AddRenderer(self._renderer)
self._ren_win.Render()
# CAMERA
self._camera = self._renderer.GetActiveCamera()
self._camera.SetPosition(13, 0, 0)
self._vtk_widget.Start()
# TIMER
self._timer = QTimer()
self._timer.setInterval(int(1000 / 60))
self._timer.timeout.connect(self._render_once)
self._timer.start()
def render(self):
"""Render to display"""
# define the renderer
ren = vtk.vtkOpenGLRenderer()
ren.SetBackground(*self._vtk_args.background_colour)
# populate the renderer with the meshes
for segment in self.segments:
ren = segment.render(ren)
# render window
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
if self._vtk_args.full_screen:
renWin.FullScreenOn()
# render window interactor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
# from vtkCubeAxesActor.h
# define VTK_FLY_OUTER_EDGES 0
# define VTK_FLY_CLOSEST_TRIAD 1
# define VTK_FLY_FURTHEST_TRIAD 2
# define VTK_FLY_STATIC_TRIAD 3
# define VTK_FLY_STATIC_EDGES 4
if self._vtk_args.cube_axes is not None:
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetBounds(ren.ComputeVisiblePropBounds())
cubeAxesActor.SetCamera(ren.GetActiveCamera())
cubeAxesActor.SetFlyMode(self._vtk_args.cube_axes)
cubeAxesActor.SetFlyModeToStaticEdges(
) # how the cube axes will appear
cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.GetTitleTextProperty(1).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.GetTitleTextProperty(2).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
ren.AddActor(cubeAxesActor)
# _actor_count += 1
# assert ren.VisibleActorCount() == _actor_count
# axes: display axes by default
if not self._vtk_args.no_orientation_axes:
axesActor = vtk.vtkAxesActor()
axesWidget = vtk.vtkOrientationMarkerWidget()
axesWidget.SetOrientationMarker(axesActor)
axesWidget.SetViewport(0, 0, 0.1, 0.1)
axesWidget.SetInteractor(iren)
axesWidget.SetEnabled(1)
ren.ResetCamera()
# hello...
print_date("Initialising...")
iren.Initialize()
print_date("Launching VTK viewer...")
iren.Start()
print_date("3D view completed.")
def __init__(self, parent):
super(QMeshViewer, self).__init__(parent)
# Make the actual QtWidget a child so that it can be re_parented
interactor = QVTKRenderWindowInteractor(self)
self.layout = QtWidgets.QHBoxLayout()
self.layout.addWidget(interactor)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
# set up my VTK Visualization pipeline
# cut-and-paste from https://lorensen.github.io/VTKExamples/site/Python/GeometricObjects/Sphere/
colors = vtk.vtkNamedColors()
# Create a sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(0.0, 0.0, 0.0)
sphereSource.SetRadius(5.0)
# Make the surface smooth
sphereSource.SetPhiResolution(100)
sphereSource.SetThetaResolution(100)
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(sphereSource.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(colors.GetColor3d("Cornsilk"))
actor.GetProperty().SetRepresentation(0)
actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Cornsilk"))
actor.GetProperty().SetDiffuse(0.8)
actor.GetProperty().SetSpecular(0.5)
actor.GetProperty().SetSpecularColor(1., 1., 1.)
actor.GetProperty().SetSpecularPower(30.)
renderer = vtk.vtkOpenGLRenderer()
render_window = interactor.GetRenderWindow()
render_window.AddRenderer(renderer)
# TEST
# interactor.SetRenderWindow(render_window)
#render_window.SetInteractor(interactor)
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d("DarkGreen"))
self.render_window = render_window
self.interactor = interactor
self.renderer = renderer
self.sphere = sphereSource
self.actor = actor
def __init__(self):
super().__init__()
# WIDGET
self._widget = QWidget(self)
self._widget.setAttribute(Qt.WA_TranslucentBackground | Qt.SubWindow)
self.setCentralWidget(self._widget)
self.resize(900, 900)
self._widget.event = types.MethodType(self._handle_event, self._widget)
self._widget.setAttribute(Qt.WA_AcceptTouchEvents) # 与半透明分开设置
# VTK
self._vtk_widget = QVTKRenderWindowInteractor(self._widget)
self._vtk_widget.resize(900, 900)
self._ren_win = self._vtk_widget.GetRenderWindow()
# CAMERA
self._interactor = self._ren_win.GetInteractor()
self._vtk_widget.SetInteractorStyle(MyEvent())
# RENDER
self._renderer = vtk.vtkOpenGLRenderer()
self._renderer.SetBackground((0, 0, 0))
self._renderer.AddActor(self._axis_actor())
self._ren_win.AddRenderer(self._renderer)
# CAMERA
self._camera = self._renderer.GetActiveCamera()
# self._camera_angle = self._camera.GetViewAngle()
# self._camera_last_angle = 30
self._camera_pose = [0, 0, 13]
self._last_camera_pose = [0, 0, 0]
self.set_camera_pose(pos=[0, 0, 13.0], center=[0, 0, 0], view=[0, 0, 0])
self._vtk_widget.Start()
# BUTTON WIDGET
widget = QWidget(self._widget)
widget.resize(200, 200)
widget.setStyleSheet('QWidget {background: red}')
widget.setToolTip('button test')
widget.show()
button = QPushButton(widget)
button.setStyleSheet('QPushButton {background: blue}')
button.setText('test')
button.pressed.connect(self._widget_display)
button.show()
# TIMER
self._event_ena = False
self._timer = QTimer(self)
self._timer.setInterval(int(1000/100))
self._timer.timeout.connect(self._detect_event)
self._timer.start()
self._high_timer = QTimer(self)
self._high_timer.setInterval(int(1000/60))
self._high_timer.timeout.connect(self._render_once)
def render_simulation_for_multiprocess(path, n_particles, first_step,
last_step, min_Psi, max_Psi,
particles_size, cube_size, camera, view,
info, process_number):
#start_time = tm.time()
#if (info>0):
# print("path: ", path , "\n", "first step: ", first_step, " last step: ", last_step)
# print(" min_Psi: ", min_Psi, " max_Psi: ", max_Psi, " time_step: ", time_step, "ms")
total_steps = last_step - first_step + 1
renderer = vtk.vtkOpenGLRenderer()
renderer.SetBackground(bg_color, bg_color, bg_color)
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(2048, 1536)
#Disables the 3D render window
renderWindow.SetOffScreenRendering(1)
renWinInteractor = vtk.vtkRenderWindowInteractor()
for actual_step in range(0, total_steps):
actor = actor_man.create_actor(path, n_particles,
actual_step + first_step, min_Psi,
max_Psi, particles_size)
renderer.AddViewProp(actor)
'''
#Add cube to the render
cubeActor = actor_man.create_cube_actor(cube_size)
renderer.AddViewProp(cubeActor)
cubeAxes = actor_man.cube_axes(cube_size)
renderer.AddViewProp(cubeAxes)
'''
renderWindow.AddRenderer(renderer)
renWinInteractor.SetRenderWindow(renderWindow)
renWinInteractor.Render()
renWinInteractor.Initialize()
if (info > 0):
print("Pr:", process_number, " Step:", actual_step + first_step)
img_save.save_image_camera_setup(renderer, actual_step + first_step,
camera, view)
#img_save.export_image(renderer, actual_step + first_step)
renderer.RemoveAllViewProps()
def initScene(self):
qDebug('initScene()')
self.renderer = vtk.vtkOpenGLRenderer()
self.render_window = self.interactor.GetRenderWindow()
self.render_window.AddRenderer(self.renderer)
self.cellPicker = vtk.vtkCellPicker()
self.cellPicker.SetTolerance(30.0)
self.interactor.SetPicker(self.cellPicker)
#* Top background color
bg_t = np.ones(3) * 245.0 / 255.0
#* Bottom background color
bg_b = np.ones(3) * 170.0 / 255.0
self.renderer.SetBackground(bg_t)
self.renderer.SetBackground2(bg_b)
self.renderer.GradientBackgroundOn()
def render_simulation(path, n_particles, first_step, last_step, min_Psi,
max_Psi, time_step, particles_size, cube_size, info):
if (info > 0):
print("path: ", path, "\n", "first step: ", first_step,
" last step: ", last_step)
print(" min_Psi: ", min_Psi, " max_Psi: ", max_Psi, " time_step: ",
time_step, "ms")
actor = actor_man.create_actor(path, n_particles, first_step, min_Psi,
max_Psi, particles_size)
renderer = vtk.vtkOpenGLRenderer()
renderer.SetBackground(bg_color, bg_color, bg_color)
renderer.AddViewProp(actor)
cubeActor = actor_man.create_cube_actor(cube_size)
renderer.AddViewProp(cubeActor)
cubeAxes = actor_man.cube_axes(cube_size)
renderer.AddViewProp(cubeAxes)
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(1600, 1200)
renderWindow.AddRenderer(renderer)
renWinInteractor = vtk.vtkRenderWindowInteractor()
renWinInteractor.SetRenderWindow(renderWindow)
renWinInteractor.Render()
print("Steps:")
print(first_step)
# Initialize must be called prior to creating timer events.
renWinInteractor.Initialize()
# Sign up to receive TimerEvent
timerCallback = vtkTimerCallback(path, n_particles, first_step + 1,
last_step, min_Psi, max_Psi,
particles_size, cube_size, info)
timerCallback.actor = actor
renWinInteractor.AddObserver('TimerEvent', timerCallback.execute)
timerId = renWinInteractor.CreateRepeatingTimer(time_step)
renWinInteractor.Start()
def __init__(self,frame): self.renderer = vtk.vtkOpenGLRenderer() self.renwin = vtk.vtkXOpenGLRenderWindow() self.renwin.AddRenderer(self.renderer) self.renwin.SetStereoTypeToAnaglyph() #self.renwin.SetAnaglyphColorMask(4,2) self.iren = vtkTkRenderWindowInteractor(frame,rw=self.renwin, width=300, height=300 ) self.istyle = vtk.vtkInteractorStyleSwitch() self.iren.SetInteractorStyle(self.istyle) self.istyle.SetCurrentStyleToTrackballCamera() self.iren.Initialize() self.iren.pack(side='bottom', fill='none', expand=0) self.iren.Start() self.camera=vtk.vtkCamera() self.camera.SetFocalPoint(0, 0, 0) self.camera.SetPosition(0, 0, 250) self.camera.SetViewUp(0, 0, 0) self.camera.SetEyeAngle(5.0) self.renderer.SetActiveCamera(self.camera) self.renwin.Render()
def setenv(self,root): self.renderer = vtk.vtkOpenGLRenderer() #self.renderer.SetBackground(1,1,1) self.renwin = vtk.vtkXOpenGLRenderWindow() self.renwin.AddRenderer(self.renderer) #self.renwin.SetStereoTypeToRedBlue() #self.renwin.StereoCapableWindowOn() #self.renwin.SetStereoTypeToCrystalEyes() #self.renwin.StereoRenderOn() #activer la stereoscopie self.renwin.SetStereoTypeToAnaglyph() #self.renwin.SetAnaglyphColorMask(4,2) #gauche,droite | r=4, v=2 ,b=1 self.iren = vtkTkRenderWindowInteractor(root,rw=self.renwin, width=1000, height=800) self.istyle = vtk.vtkInteractorStyleSwitch() self.iren.SetInteractorStyle(self.istyle) self.istyle.SetCurrentStyleToTrackballCamera() self.iren.Initialize() self.iren.pack(side='top', fill='both', expand=1) self.addobservers() self.setcam() self.setaxes() #self.make_fog() #charger le fog par defaut ? /!\ modifier la variable has_fog self.iren.Start() self.display_ascii_logo()
outlineData.SetInputConnection(reader.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapOutline)
actor.GetProperty().SetColor(colors.GetColor3d("Black"))
return actor
colors = vtk.vtkNamedColors()
colors.SetColor("SkinColor", 255, 125, 64, 0)
renderer = vtk.vtkOpenGLRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
fileName1 = '/home/jmh/github/data/MRI/MR-Abdomen.mhd'
skinActor = CreateSkinActor(fileName1)
skinActor.GetProperty().SetColor(colors.GetColor3d("SkinColor"))
skinActor.GetProperty().SetOpacity(.9) # 0.4
renderer.AddActor(skinActor)
outline = CreateOutline(fileName1)
renderer.AddActor(outline)
def main():
interactor = vtk.vtkRenderWindowInteractor()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(400, 400)
renderWindow.SetMultiSamples(0)
renderWindow.SetAlphaBitPlanes(1)
interactor.SetRenderWindow(renderWindow)
renderer = vtk.vtkOpenGLRenderer()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
rectangleSource = vtk.vtkPlaneSource()
rectangleSource.SetOrigin(-5.0, 0.0, 5.0)
rectangleSource.SetPoint1(5.0, 0.0, 5.0)
rectangleSource.SetPoint2(-5.0, 0.0, -5.0)
rectangleSource.SetResolution(100, 100)
rectangleMapper = vtk.vtkPolyDataMapper()
rectangleMapper.SetInputConnection(rectangleSource.GetOutputPort())
rectangleMapper.SetScalarVisibility(0)
shadows = vtk.vtkShadowMapPass()
seq = vtk.vtkSequencePass()
passes = vtk.vtkRenderPassCollection()
passes.AddItem(shadows.GetShadowMapBakerPass())
passes.AddItem(shadows)
seq.SetPasses(passes)
cameraP = vtk.vtkCameraPass()
cameraP.SetDelegatePass(seq)
# tell the renderer to use our render pass pipeline
glrenderer = renderer
glrenderer.SetPass(cameraP)
colors = vtk.vtkNamedColors()
boxColor = colors.GetColor3d("Tomato")
rectangleColor = colors.GetColor3d("Beige")
coneColor = colors.GetColor3d("Peacock")
sphereColor = colors.GetColor3d("Banana")
rectangleActor = vtk.vtkActor()
rectangleActor.SetMapper(rectangleMapper)
rectangleActor.VisibilityOn()
rectangleActor.GetProperty().SetColor(rectangleColor)
boxSource = vtk.vtkCubeSource()
boxSource.SetXLength(2.0)
boxNormals = vtk.vtkPolyDataNormals()
boxNormals.SetInputConnection(boxSource.GetOutputPort())
boxNormals.ComputePointNormalsOff()
boxNormals.ComputeCellNormalsOn()
boxNormals.Update()
boxNormals.GetOutput().GetPointData().SetNormals(None)
boxMapper = vtk.vtkPolyDataMapper()
boxMapper.SetInputConnection(boxNormals.GetOutputPort())
boxMapper.ScalarVisibilityOff()
boxActor = vtk.vtkActor()
boxActor.SetMapper(boxMapper)
boxActor.VisibilityOn()
boxActor.SetPosition(-2.0, 2.0, 0.0)
boxActor.GetProperty().SetColor(boxColor)
coneSource = vtk.vtkConeSource()
coneSource.SetResolution(24)
coneSource.SetDirection(1.0, 1.0, 1.0)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(coneSource.GetOutputPort())
coneMapper.SetScalarVisibility(0)
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
coneActor.VisibilityOn()
coneActor.SetPosition(0.0, 1.0, 1.0)
coneActor.GetProperty().SetColor(coneColor)
sphereSource = vtk.vtkSphereSource()
sphereSource.SetThetaResolution(32)
sphereSource.SetPhiResolution(32)
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereMapper.ScalarVisibilityOff()
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
sphereActor.VisibilityOn()
sphereActor.SetPosition(2.0, 2.0, -1.0)
sphereActor.GetProperty().SetColor(sphereColor)
renderer.AddViewProp(rectangleActor)
renderer.AddViewProp(boxActor)
renderer.AddViewProp(coneActor)
renderer.AddViewProp(sphereActor)
# Spotlights.
# lighting the box.
l1 = vtk.vtkLight()
l1.SetPosition(-4.0, 4.0, -1.0)
l1.SetFocalPoint(boxActor.GetPosition())
l1.SetColor(1.0, 1.0, 1.0)
l1.PositionalOn()
renderer.AddLight(l1)
l1.SwitchOn()
# lighting the sphere
l2 = vtk.vtkLight()
l2.SetPosition(4.0, 5.0, 1.0)
l2.SetFocalPoint(sphereActor.GetPosition())
l2.SetColor(1.0, 0.0, 1.0)
l2.PositionalOn()
renderer.AddLight(l2)
l2.SwitchOn()
# For each spotlight, add a light frustum wireframe representation and a cone
# wireframe representation, colored with the light color.
angle = l1.GetConeAngle()
if l1.LightTypeIsSceneLight() and l1.GetPositional(
) and angle < 180.0: # spotlight
la = vtk.vtkLightActor()
la.SetLight(l1)
renderer.AddViewProp(la)
angle = l2.GetConeAngle()
if l2.LightTypeIsSceneLight() and l2.GetPositional(
) and angle < 180.0: # spotlight
la = vtk.vtkLightActor()
la.SetLight(l2)
renderer.AddViewProp(la)
renderer.SetBackground2(colors.GetColor3d("Silver"))
renderer.SetBackground(colors.GetColor3d("LightGrey"))
renderer.SetGradientBackground(True)
renderWindow.Render()
renderWindow.SetWindowName('ShadowsLightsDemo')
renderer.ResetCamera()
camera = renderer.GetActiveCamera()
camera.Azimuth(40.0)
camera.Elevation(10.0)
renderWindow.Render()
interactor.Start()
def main():
if not vtk_version_ok(8, 90, 0):
print('You need VTK version 8.90 or greater to run this program.')
return
path, surface = get_program_parameters()
cube_path = Path(path)
if not cube_path.is_dir():
print('This path does not exist:', cube_path)
return
surface = surface.lower()
available_surfaces = {'boy', 'mobius', 'randomhills', 'torus', 'sphere', 'cube'}
if surface not in available_surfaces:
surface = 'boy'
if surface == 'mobius':
source = GetMobius()
elif surface == 'randomhills':
source = GetRandomHills()
elif surface == 'torus':
source = GetTorus()
elif surface == 'sphere':
source = GetSphere()
elif surface == 'cube':
source = GetCube()
else:
source = GetBoy()
# Load the cube map
# cubemap = ReadCubeMap(cube_path, '/', '.jpg', 0)
cubemap = ReadCubeMap(cube_path, '/', '.jpg', 1)
# cubemap = ReadCubeMap(cube_path/'skybox','', '.jpg', 2)
# Load the skybox
# Read it again as there is no deep copy for vtkTexture
# skybox = ReadCubeMap(cube_path, '/', '.jpg', 0)
skybox = ReadCubeMap(cube_path, '/', '.jpg', 1)
# skybox = ReadCubeMap(cube_path, '/skybox', '.jpg', 2)
skybox.InterpolateOn()
skybox.MipmapOn()
skybox.RepeatOff()
skybox.EdgeClampOn()
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [26, 51, 102, 255])
renderer = vtk.vtkOpenGLRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Lets use a smooth metallic surface
metallicCoefficient = 1.0
roughnessCoefficient = 0.05
slwP = SliderProperties()
slwP.initialValue = metallicCoefficient
slwP.title = 'Metallicity'
sliderWidgetMetallic = MakeSliderWidget(slwP)
sliderWidgetMetallic.SetInteractor(interactor)
sliderWidgetMetallic.SetAnimationModeToAnimate()
sliderWidgetMetallic.EnabledOn()
slwP.initialValue = roughnessCoefficient
slwP.title = 'Roughness'
slwP.p1 = [0.1, 0.9]
slwP.p2 = [0.9, 0.9]
sliderWidgetRoughness = MakeSliderWidget(slwP)
sliderWidgetRoughness.SetInteractor(interactor)
sliderWidgetRoughness.SetAnimationModeToAnimate()
sliderWidgetRoughness.EnabledOn()
# Build the pipeline
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(source)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer.UseImageBasedLightingOn()
if vtk_version_ok(9, 0, 0):
renderer.SetEnvironmentTexture(cubemap)
else:
renderer.SetEnvironmentCubeMap(cubemap)
actor.GetProperty().SetInterpolationToPBR()
# configure the basic properties
actor.GetProperty().SetColor(colors.GetColor3d('White'))
actor.GetProperty().SetMetallic(metallicCoefficient)
actor.GetProperty().SetRoughness(roughnessCoefficient)
# Create the slider callbacks to manipulate metallicity and roughness
sliderWidgetMetallic.AddObserver(vtk.vtkCommand.InteractionEvent, SliderCallbackMetallic(actor.GetProperty()))
sliderWidgetRoughness.AddObserver(vtk.vtkCommand.InteractionEvent, SliderCallbackRoughness(actor.GetProperty()))
renderer.SetBackground(colors.GetColor3d("BkgColor"))
renderer.AddActor(actor)
skyboxActor = vtk.vtkSkybox()
skyboxActor.SetTexture(skybox)
renderer.AddActor(skyboxActor)
renderer.UseSphericalHarmonicsOff()
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindow.SetWindowName("Skybox-PBR")
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
rgba = [0.0, 0.0, 0.0, 0.0]
colors.GetColor("Carrot", rgba)
widget.SetOutlineColor(rgba[0], rgba[1], rgba[2])
widget.SetOrientationMarker(axes)
widget.SetInteractor(interactor)
widget.SetViewport(0.0, 0.2, 0.2, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def __init__(self):
super().__init__()
signal.signal(signal.SIGINT, self.exit)
self._screen_size = QApplication.primaryScreen().size()
# WIDGET
self._widget = QWidget(self)
self.setCentralWidget(self._widget)
self._widget.resize(self._screen_size)
self._widget.event = types.MethodType(self._handle_event, self._widget)
self._widget.setAttribute(Qt.WA_AcceptTouchEvents | Qt.WA_TranslucentBackground)
self._widget.setWindowFlags(Qt.NoDropShadowWindowHint)
# VTK
self._vtk_widget = QVTKRenderWindowInteractor(self._widget)
self._vtk_widget.resize(self._screen_size)
self._ren_win = self._vtk_widget.GetRenderWindow()
self._interactor = self._ren_win.GetInteractor()
self._vtk_widget.SetInteractorStyle(InteractorStyle())
self._sw, self._sh = self._screen_size.width(), self._screen_size.height()
self.resize(int(self._sw * 0.7), int(self._sh * 0.7))
self.move(int(self._sw * (1 - 0.7) / 2), int(self._sh * (1 - 0.7) / 2))
# STYLE
self._widget.setFocus()
QApplication.setStyle('Fusion')
# self.setAttribute(Qt.WA_TranslucentBackground)
# 开启touch事件之后
# QMainWindow不可开启此方法，会把子类所有插件变透明，且报qt.qpa.xcb: QXcbConnection: XCB error: 8 (BadMatch) 错误
# TEST_DOCK
self._dock = QWidget(self)
self._dock.resize(70, 150)
self._dock.move(int(self._sw * 0.7 - 80), 100)
self._dock.setStyleSheet('QWidget {background: rgb(60, 60, 60)}')
self._dock.show()
# TEST_BTN
self._button = QPushButton(self._dock)
self._button.setText('test')
self._button.setStyleSheet('QPushButton {background: rgb(255, 255, 255)}')
self._button.pressed.connect(self._pressed)
self._button.released.connect(self._released)
self._button.resize(60, 60)
self._button.move(5, 5)
self._button.show()
# TEST_PANEL
self._bar = QWidget(self)
self._bar.resize(340, 450)
self._bar.move(int(self._sw * 0.7 - 425), 100)
self._bar.show()
self._bar.setVisible(False)
# TEST_TOOL_BOX
self._tool_box = QToolBox(self._bar)
self._tool_box.resize(340, 450)
self._tool_box.show()
# RENDER
self._renderer = vtk.vtkOpenGLRenderer()
self._renderer.SetBackground((0, 0, 0))
self._renderer.AddActor(self._axis_actor())
self._renderer.AddActor(self._stl_actor())
self._camera = self._renderer.GetActiveCamera()
self._ren_win.AddRenderer(self._renderer)
self._ren_win.Render()
# CAMERA
self._camera = self._renderer.GetActiveCamera()
self._camera.SetPosition(13, 0, 0)
self._vtk_widget.Start()
# TIMER
self._timer = QTimer()
self._timer.setInterval(int(1000 / 60))
self._timer.timeout.connect(self._render_once)
self._timer.start()
mixer_contour.SetValue(0, 1)
stream_actors = make_stream_actors((0, 15, 30), (0, 1, 0))
stream_actors += make_stream_actors((0, 45, 30), (0, 0, 1))
mixer_geometry = vtk.vtkPolyDataMapper()
mixer_geometry.SetInputConnection(mixer_contour.GetOutputPort())
mixer_geometry.ScalarVisibilityOff()
mixer_actor = vtk.vtkOpenGLActor()
mixer_actor.SetMapper(mixer_geometry)
mixer_actor.GetProperty().SetColor(.5, .5, .5)
mixer_actor.GetProperty().SetOpacity(1.)
# Standard vtk environment stuff
renderer = vtk.vtkOpenGLRenderer()
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_interactor = vtk.vtkRenderWindowInteractor()
renderer.AddActor(mixer_actor)
for actor in stream_actors:
renderer.AddActor(actor)
renderer.SetBackground(0.1, 0.1, 0.1)
render_window.SetSize(500, 500)
render_interactor.SetRenderWindow(render_window)
def exit_check(obj, event):
if obj.GetEventPending():
obj.SetAbortRender(1)
def display(volumes, args):
"""Display the volumes provided in the iterable
This function relies on VTK to do the visualisation.
:param list volumes: a list of either MAP, STA or TransformedSTA object
:param args: command-line arguments
:type args: argparse.Namespace
"""
# display data
# create an actor for each datum
actors = list()
for volume in volumes:
# source
vol = vtk.vtkImageData()
z_size, y_size, x_size = volume.data.shape
x_origin, y_origin, z_origin = volume.origin
# this is a weirdly complex calculation
# suppose I have a distance of size D (distance)
# the index of the first position is S (start)
# the index of the last position is E (end)
# the relationship between these three values is
# E - S + 1 = D
# therefore, E = D + S - 1
vol.SetExtent(
x_origin, x_size + x_origin - 1,
y_origin, y_size + y_origin - 1,
z_origin, z_size + z_origin - 1,
)
vol.SetOrigin(x_origin, y_origin, z_origin)
sp_x = volume.x_voxel_size
sp_y = volume.y_voxel_size
sp_z = volume.z_voxel_size
vol.SetSpacing(sp_x, sp_y, sp_z)
vol.AllocateScalars(vtk.VTK_FLOAT, 1)
# voxel data
print(f"Inserting voxel data...", end="")
# numpy to vtk; https://pyscience.wordpress.com/2014/09/06/numpy-to-vtk-converting-your-numpy-arrays-to-vtk-arrays-and-files/
voxels = vtk.util.numpy_support.numpy_to_vtk(volume.data.ravel(), deep=1, array_type=vtk.VTK_FLOAT)
print(f"done!")
vol.GetPointData().SetScalars(voxels)
# contour
contours = vtk.vtkContourFilter()
contours.SetInputData(vol)
contours.SetValue(0, args.contour_level)
contours.Update()
contoursOutput = contours.GetOutput()
# data
obj = vtk.vtkPolyData()
obj.SetPoints(contoursOutput.GetPoints())
obj.SetPolys(contoursOutput.GetPolys())
# mapper
mapper = vtk.vtkOpenGLPolyDataMapper()
mapper.SetInputData(obj)
# actor & transform
actor = vtk.vtkOpenGLActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(volume.colour)
actor.GetProperty().SetOpacity(volume.opacity)
if isinstance(volume, TransformedSTA):
transform = vtk.vtkTransform()
matrix = vtk.vtkMatrix4x4()
for i in range(4):
for j in range(4):
matrix.SetElement(i, j, volume.transform[i, j])
transform.SetMatrix(matrix)
print(transform)
actor.SetUserTransform(transform)
actors += [actor]
# renderer
renderer = vtk.vtkOpenGLRenderer()
[renderer.AddActor(actor) for actor in actors]
# cube axes
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetBounds(renderer.ComputeVisiblePropBounds())
cubeAxesActor.SetCamera(renderer.GetActiveCamera())
cubeAxesActor.SetFlyMode(4)
cubeAxesActor.SetFlyModeToStaticEdges() # how the cube axes will appear
cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.GetTitleTextProperty(1).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.GetTitleTextProperty(2).SetColor(1.0, 1.0, 1.0)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
renderer.AddActor(cubeAxesActor)
# rendererwindow
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# render window interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
render_window_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
axes_actor = vtk.vtkAxesActor()
axes_widget = vtk.vtkOrientationMarkerWidget()
axes_widget.SetOrientationMarker(axes_actor)
axes_widget.SetViewport(0, 0, 0.2, 0.2)
axes_widget.SetInteractor(render_window_interactor)
axes_widget.SetEnabled(1)
renderer.ResetCamera()
# display
render_window_interactor.Initialize()
render_window_interactor.Start()
return os.EX_OK
def __init__(self, file_list,spacing_list,feature_type,irad = 1.2, h_th=-200,
glyph_type='sphere', glyph_scale_factor=1,use_field_data=True, opacity_list=[],
color_list=[], lung=[]):
assert feature_type == "ridge_line" or feature_type == "valley_line" \
or feature_type == "ridge_surface" or feature_type == "valley_surface" \
or feature_type == "vessel" or feature_type == "airway" \
or feature_type == "fissure", "Invalid feature type"
if feature_type == "airway":
feature_type = "valley_line"
elif feature_type == "vessel":
feature_type = "ridge_line"
elif feature_type == "fissure":
feature_type = "ridge_surface"
self.mapper_list = list()
self.actor_list = list()
self.glyph_list = list()
self.glyph_type = glyph_type
self.file_list = file_list
self.spacing_list = spacing_list
self.opacity_list = opacity_list
self.irad = irad
self.h_th = h_th
self.color_list = color_list
self.lung = lung
self.use_field_data = use_field_data
self.feature_type = feature_type
self.normal_map=dict()
self.normal_map['ridge_line'] = "hevec0"
self.normal_map['valley_line'] = "hevec2"
self.normal_map['ridge_surface'] = "hevec2"
self.normal_map['valley_surface'] = "hevec0"
self.strength_map=dict()
self.strength_map['ridge_line'] = "h1"
self.strength_map['valley_line'] = "h1"
self.strength_map['ridge_surface'] = "h2"
self.strength_map['valley_surface'] = "h0"
if feature_type == 'ridge_line' or feature_type == 'valley_line':
self.height = irad
self.radius = 0.5
elif feature_type == 'ridge_surface' or feature_type == 'valley_surface':
self.height = 0.5
self.radius = irad
self.min_rad = 0.5
self.max_rad = 6
self.glyph_scale_factor = glyph_scale_factor
self.capture_prefix = ""
self.capture_count = 1
self.image_count = 1
# VTK Objects
self.ren = vtk.vtkOpenGLRenderer()
self.renWin = vtk.vtkRenderWindow()
self.iren = vtk.vtkRenderWindowInteractor()
# Volume rendering objects
self.volumeActor = vtk.vtkVolume()
self.volumeMapper = vtk.vtkVolumeRayCastMapper()
#self.volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
# Variables for the interaction
self.volume_loaded = False
self.volume_added_to_renderer = False
self.volume_size = [0,0,0]
self.particles_loaded = False
self.particles_added_to_renderer = False
self.planeWidgetX = vtk.vtkImagePlaneWidget()
self.planeWidgetY = vtk.vtkImagePlaneWidget()
self.planeWidgetZ = vtk.vtkImagePlaneWidget()
self.lastPlaneWidget = self.planeWidgetX
self.lastPlaneWidgetIndex = 0
self.planeWidgetLayer = [0,0,0]
self.boxWidgetVolume = vtk.vtkBoxWidget()
self.boxWidgetParticles = vtk.vtkBoxWidget()
self.planesParticles = vtk.vtkPlanes()
self.planesParticles.SetBounds(-10000,10000,-10000,10000,-10000,10000); # For some reason planes needs initializaiton
self.planesVolume = vtk.vtkPlanes()
self.planesVolume.SetBounds(-10000,10000,-10000,10000,-10000,10000); # For some reason planes needs initializaiton
def __init__(self, window_zoom=0.1):
super().__init__()
signal.signal(signal.SIGINT, self.exit)
# WINDOW
# self._screen_size = QApplication.primaryScreen().size()
self.resize(1800, 1200)
self._center_widget = QWidget(self)
self._center_widget.setWindowFlags(Qt.NoDropShadowWindowHint)
self._center_widget.resize(1800, 1200)
self._vtk_widget = QVTKRenderWindowInteractor(self._center_widget)
self._vtk_widget.resize(1800, 1200)
self.setCentralWidget(self._center_widget)
self._center_widget.setFocus()
self._ren_win = self._vtk_widget.GetRenderWindow()
self._interactor = self._ren_win.GetInteractor()
QApplication.setStyle('Fusion')
self.setWindowFlags(Qt.NoDropShadowWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
# LABEL_WIDGET
self._label_widget = QWidget(self._center_widget)
self._label_widget.resize(300, 200)
# POS_LABEL
self._pos_label = QLabel(self._label_widget)
self._pos_label.move(20, 50)
self._pos_label.resize(200, 30)
self._pos_label.setStyleSheet('QLabel {color: red}')
self._pos_label.setText('pos: ')
# TOUCH_POINT_LABEL
self._touch_points = 0
self._touch_point_label = QLabel(self._label_widget)
self._touch_point_label.move(20, 80)
self._touch_point_label.resize(100, 30)
self._touch_point_label.setStyleSheet('QLabel {color: red}')
self._touch_point_label.setText('touch points: ')
self._label_widget.setAttribute(Qt.WA_TranslucentBackground)
self._label_widget.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
self._label_widget.show()
# WIDGET
self._widget = QWidget(self._center_widget)
self._widget.resize(1800, 1200)
self._widget.event = types.MethodType(self._handle_event, self._widget)
self._widget.setAttribute(Qt.WA_AcceptTouchEvents) # 与半透明分开设置
# # POS_LABEL
# self._pos_label = QLabel(self._widget)
# self._pos_label.move(1500, 50)
# self._pos_label.resize(250, 30)
# self._pos_label.setStyleSheet('QLabel {color: red}')
# self._pos_label.setText('pos: ')
# # TOUCH_POINT_LABEL
# self._touch_points = 0
# self._touch_point_label = QLabel(self._widget)
# self._touch_point_label.move(1500, 80)
# self._touch_point_label.resize(100, 30)
# self._touch_point_label.setStyleSheet('QLabel {color: red}')
# self._touch_point_label.setText('touch points: ')
self._timer = QTimer()
self._widget.setAttribute(Qt.WA_TranslucentBackground)
self._widget.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
self._widget.show()
# TIMER
self._timer.setInterval(int(1000 / 60))
self._timer.timeout.connect(self._render_once)
self._timer.start()
# RENDER
self._renderer = vtk.vtkOpenGLRenderer()
self._renderer.SetBackground((0, 0, 0))
self._renderer.AddActor(self._axis_actor())
self._ren_win.AddRenderer(self._renderer)
# CAMERA
self._camera = self._renderer.GetActiveCamera()
self._camera_pose = [0, 0, 13]
self._last_camera_pose = [0, 0, 0]
self._camera_view = [0, 0, 0]
self._last_camera_view = [0, 0, 0]
self.set_camera_pose(pos=[0, 0, 13.0],
center=[0, 0, 0],
view=[0, 0, 0])
self._vtk_widget.Start()
# MOUSE_POS_THREAD
self._thread_switch = False
self._mouse_pos = self._widget.mapFromGlobal(QCursor.pos())
self._last_mouse_pos = self._widget.mapFromGlobal(QCursor.pos())
self._thread = None
def main():
if not vtk_version_ok(8, 90, 0):
print('You need VTK version 8.90 or greater to run this program.')
return
path, material_fn, albedo_fn, normal_fn, emissive_fn, surface = get_program_parameters(
)
cube_path = Path(path)
if not cube_path.is_dir():
print('This path does not exist:', cube_path)
return
# Load the cube map
# cubemap = ReadCubeMap(cube_path, '/', '.jpg', 0)
cubemap = ReadCubeMap(cube_path, '/', '.jpg', 1)
# cubemap = ReadCubeMap(cube_path, '/skybox', '.jpg', 2)
# Load the skybox
# Read it again as there is no deep copy for vtkTexture
# skybox = ReadCubeMap(cube_path, '/', '.jpg', 0)
skybox = ReadCubeMap(cube_path, '/', '.jpg', 1)
# skybox = ReadCubeMap(cube_path, '/skybox', '.jpg', 2)
skybox.InterpolateOn()
skybox.RepeatOff()
skybox.EdgeClampOn()
# Get the textures
material = GetTexture(material_fn)
albedo = GetTexture(albedo_fn)
albedo.UseSRGBColorSpaceOn()
normal = GetTexture(normal_fn)
emissive = GetTexture(emissive_fn)
emissive.UseSRGBColorSpaceOn()
# Get the surface
surface = surface.lower()
available_surfaces = {
'boy', 'mobius', 'randomhills', 'torus', 'sphere', 'cube'
}
if surface not in available_surfaces:
surface = 'boy'
if surface == 'mobius':
source = GetMobius()
elif surface == 'randomhills':
source = GetRandomHills()
elif surface == 'torus':
source = GetTorus()
elif surface == 'sphere':
source = GetSphere()
elif surface == 'cube':
source = GetCube()
else:
source = GetBoy()
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [26, 51, 102, 255])
colors.SetColor('VTKBlue', [6, 79, 141, 255])
# Let's make a complementary colour to VTKBlue
colors.SetColor('VTKBlueComp', [249, 176, 114, 255])
renderer = vtk.vtkOpenGLRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Lets use a rough metallic surface
metallicCoefficient = 1.0
roughnessCoefficient = 0.8
# Other parameters
occlusionStrength = 10.0
normalScale = 10.0
emissiveCol = colors.GetColor3d('VTKBlueComp')
emissiveFactor = emissiveCol
# emissiveFactor = [1.0, 1.0, 1.0]
slwP = SliderProperties()
slwP.initialValue = metallicCoefficient
slwP.title = 'Metallicity'
sliderWidgetMetallic = MakeSliderWidget(slwP)
sliderWidgetMetallic.SetInteractor(interactor)
sliderWidgetMetallic.SetAnimationModeToAnimate()
sliderWidgetMetallic.EnabledOn()
slwP.initialValue = roughnessCoefficient
slwP.title = 'Roughness'
slwP.p1 = [0.2, 0.9]
slwP.p2 = [0.8, 0.9]
sliderWidgetRoughness = MakeSliderWidget(slwP)
sliderWidgetRoughness.SetInteractor(interactor)
sliderWidgetRoughness.SetAnimationModeToAnimate()
sliderWidgetRoughness.EnabledOn()
slwP.initialValue = occlusionStrength
slwP.title = 'Occlusion'
slwP.p1 = [0.1, 0.1]
slwP.p2 = [0.1, 0.9]
sliderWidgetOcclusionStrength = MakeSliderWidget(slwP)
sliderWidgetOcclusionStrength.SetInteractor(interactor)
sliderWidgetOcclusionStrength.SetAnimationModeToAnimate()
sliderWidgetOcclusionStrength.EnabledOn()
slwP.initialValue = normalScale
slwP.title = 'Normal'
slwP.p1 = [0.85, 0.1]
slwP.p2 = [0.85, 0.9]
sliderWidgetNormal = MakeSliderWidget(slwP)
sliderWidgetNormal.SetInteractor(interactor)
sliderWidgetNormal.SetAnimationModeToAnimate()
sliderWidgetNormal.EnabledOn()
# Build the pipeline
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputData(source)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetInterpolationToPBR()
# configure the basic properties
actor.GetProperty().SetColor(colors.GetColor3d('White'))
actor.GetProperty().SetMetallic(metallicCoefficient)
actor.GetProperty().SetRoughness(roughnessCoefficient)
# configure textures (needs tcoords on the mesh)
actor.GetProperty().SetBaseColorTexture(albedo)
actor.GetProperty().SetORMTexture(material)
actor.GetProperty().SetOcclusionStrength(occlusionStrength)
actor.GetProperty().SetEmissiveTexture(emissive)
actor.GetProperty().SetEmissiveFactor(emissiveFactor)
# needs tcoords, normals and tangents on the mesh
actor.GetProperty().SetNormalTexture(normal)
actor.GetProperty().SetNormalScale(normalScale)
renderer.UseImageBasedLightingOn()
if vtk_version_ok(9, 0, 0):
renderer.SetEnvironmentTexture(cubemap)
else:
renderer.SetEnvironmentCubeMap(cubemap)
renderer.SetBackground(colors.GetColor3d('BkgColor'))
renderer.AddActor(actor)
# Comment out if you don't want a skybox
skyboxActor = vtk.vtkSkybox()
skyboxActor.SetTexture(skybox)
renderer.AddActor(skyboxActor)
renderer.UseSphericalHarmonicsOff()
# Create the slider callbacks to manipulate metallicity, roughness
# occlusion strength and normal scaling
sliderWidgetMetallic.AddObserver(
vtk.vtkCommand.InteractionEvent,
SliderCallbackMetallic(actor.GetProperty()))
sliderWidgetRoughness.AddObserver(
vtk.vtkCommand.InteractionEvent,
SliderCallbackRoughness(actor.GetProperty()))
sliderWidgetOcclusionStrength.AddObserver(
vtk.vtkCommand.InteractionEvent,
SliderCallbackOcclusionStrength(actor.GetProperty()))
sliderWidgetNormal.AddObserver(
vtk.vtkCommand.InteractionEvent,
SliderCallbackNormalScale(actor.GetProperty()))
renderWindow.SetSize(640, 480)
renderWindow.Render()
renderWindow.SetWindowName('PhysicallyBasedRendering')
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
rgba = [0.0, 0.0, 0.0, 0.0]
colors.GetColor('Carrot', rgba)
widget.SetOutlineColor(rgba[0], rgba[1], rgba[2])
widget.SetOrientationMarker(axes)
widget.SetInteractor(interactor)
widget.SetViewport(0.0, 0.0, 0.2, 0.2)
widget.SetEnabled(1)
widget.InteractiveOn()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
