def save(self,
filepath,
nb_loops=1,
camera_position=(-10.0, -10.0, 10.0),
resolution=(1280, 720)):
"""Save the animation in a video file.
Parameters
----------
filepath: string
Path of the output file.
nb_loop: int, optional
Number of periods to save in the file.
camera_position: 3-ple of floats, optional
The starting position of the camera in the scene.
resolution: 2-ple of ints, optional
Resolution of the video in pixels.
"""
renderer = vtk.vtkRenderer()
renderer.SetBackground(1, 1, 1) # Background color white
for actor in self.actors:
renderer.AddActor(actor)
renderer.Modified()
camera = vtk.vtkCamera()
camera.SetPosition(*camera_position)
camera.SetFocalPoint(0, 0, 0)
camera.SetViewUp(0, 0, 1)
renderer.SetActiveCamera(camera)
render_window = vtk.vtkRenderWindow()
render_window.SetSize(*resolution)
render_window.OffScreenRenderingOn()
render_window.AddRenderer(renderer)
image_filter = vtk.vtkWindowToImageFilter()
image_filter.SetInput(render_window)
image_filter.SetInputBufferTypeToRGB()
image_filter.ReadFrontBufferOff()
writer = vtk.vtkOggTheoraWriter()
writer.SetInputConnection(image_filter.GetOutputPort())
writer.SetFileName(filepath)
writer.SetRate(self.fps)
writer.Start()
for i_frame in range(nb_loops * self.frames_per_loop):
self._callback(renderer, None)
image_filter.Modified()
writer.Write()
writer.End()
render_window.Finalize()
del image_filter
del writer
del render_window
def start_export_animation_to_file(self, path, frame_rate):
self.animation_path = path
#Setup filter
self.renWin = self._renderer.GetRenderWindow()
self.imageFilter = vtk.vtkWindowToImageFilter()
self.imageFilter.SetInput(self.renWin)
self.imageFilter.SetInputBufferTypeToRGB()
self.imageFilter.ReadFrontBufferOff()
self.imageFilter.Update()
#Setup movie writer
if ".avi" in path:
self.moviewriter = vtk.vtkAVIWriter()
else:
self.moviewriter = vtk.vtkOggTheoraWriter()
self.moviewriter.SetFileName(path)
self.moviewriter.SetInputConnection(self.imageFilter.GetOutputPort())
self.moviewriter.SetRate(30)
self.moviewriter.SetQuality(2)
self.moviewriter.Start()
#
self.export_animation = True
def __init__(self, background_color=(0, 0, 0)):
"""
Main window of a bioviz 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.ren.GetActiveCamera().ParallelProjectionOn()
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.video_recorder = vtkOggTheoraWriter()
self.is_fixed_sized = False
self.minimum_size = self.minimumSize()
self.maximum_size = self.maximumSize()
self.show()
app._in_event_loop = True
self.is_active = True
self.should_reset_camera = False
app.processEvents()
def start(self, axis='x', avi_file=None):
""" creates plot and adjusts camera """
self.create_root_actors()
self.create_soil_actors()
self.iren = render_window(self.actors, "AnimateRoots", self.color_bar,
self.bounds)
renWin = self.iren.GetRenderWindow()
ren = renWin.GetRenderers().GetItemAsObject(0)
camera = ren.GetActiveCamera()
if axis == 'x':
camera.SetPosition(
[100, 0, 0.5 * (self.bounds[4] + self.bounds[5])])
camera.SetViewUp(0, 0, 1)
if axis == 'y':
camera.SetPosition(
[0, 100, 0.5 * (self.bounds[4] + self.bounds[5])])
camera.SetViewUp(0, 0, 1)
if axis == 'z':
camera.SetPosition([0, 0, 100])
camera.SetViewUp(0, 1, 0)
if axis == 'v':
camera.SetPosition(
[100, 0, 0.5 * (self.bounds[4] + self.bounds[5])])
camera.SetViewUp(0, 0, 1)
camera.Azimuth(30)
camera.Elevation(30)
if self.file:
self.windowToImageFilter = vtk.vtkWindowToImageFilter()
self.windowToImageFilter.SetInput(renWin)
self.windowToImageFilter.SetInputBufferTypeToRGB()
self.windowToImageFilter.ReadFrontBufferOff(
) # read from the back buffer
self.windowToImageFilter.Update()
w = vtk.vtkOggTheoraWriter()
w.SetFileName(self.file + ".ogv")
w.SetInputConnection(self.windowToImageFilter.GetOutputPort())
# w.SetCompressorFourCC("H264") # feeling lucky
w.Start() #
self.writer = w
def __init__(self,
stars,
iren,
maxstep,
stepsize=1,
record=False,
fname="movie.ogv"):
self.stars = stars
self.step = 0
self.maxstep = maxstep
self.stepsize = stepsize
self.recording = record
if record:
if not fname.endswith(".ogv"): fname += ".ogv"
print("WRITING NEW VID " + fname)
self.w2if = vtk.vtkWindowToImageFilter()
self.w2if.SetInput(iren.GetRenderWindow())
self.writer = vtk.vtkOggTheoraWriter()
self.writer.SetInputConnection(self.w2if.GetOutputPort())
self.writer.SetFileName(fname)
self.writer.Start()
self.writer.SetRate(ani_recordfps)
self.writer.SetQuality(2)
def record_simulation(self, width=640, height=480, file=None, step_callback=None, delta_t=None, time_limit=None):
'''record_simulation() -> Ipython.display.Video | None
Record the simulation of this scene and save the results in a video ( ogg format ).
The video is stored in a file with the given name as argument ( by default its stored
in a temporal file ).
:return: An Ipython display video object which embeds the recorded simulation if working on a jupyter
notebook environment or None otherwise.
.. note::
If you set this to a specific file and you embed the video in notebook jupyter cell,
you will experience problems when trying to record the simulation a second time ( the video will
not be updated because jupyter inserts the video in its cache )
'''
# Validate & parse input arguments
if not isinstance(width, int) or width <= 0:
raise TypeError('width must be an integer greater than zero')
if not isinstance(height, int) or height <= 0:
raise TypeError('height must be an integer greater than zero')
if step_callback is not None and not callable(step_callback):
raise TypeError('step_callback must be a callable object')
if self.is_simulation_looped():
raise RuntimeError('Simulation cannot be looped in order to be recorded')
if time_limit is None:
if self.get_simulation_time_limit() is None:
raise RuntimeError('Simulation must have a time limit in order to be recorded')
else:
self.set_simulation_time_limit(time_limit)
if delta_t is not None:
self.set_simulation_delta_time(delta_t)
simulation = self._simulation
delta_t = simulation.get_delta_time()
time_limit = simulation.get_time_limit()
filepath = file
# If file is not specified, save the video in a temporal file
if filepath is None:
file = tempfile.NamedTemporaryFile()
filepath = file.name
file.close()
# Create a new VTK window for off-screen rendering
window = vtkRenderWindow()
window.SetOffScreenRendering(1)
window.AddRenderer(self._renderer)
window.SetSize(width, height)
window.Render()
filter = vtkWindowToImageFilter()
filter.SetInput(window)
filter.Update()
# Prepare an OGG file writer
writer = vtkOggTheoraWriter()
writer.SetFileName(filepath)
writer.SetRate(floor(1/delta_t))
writer.SetInputConnection(filter.GetOutputPort())
writer.Start()
# Stop the simulation if it was already started
if not simulation.is_stopped():
simulation.stop()
def on_step(*args, **kwargs):
# This is a callback that will be called on each simulation step
progress = floor((simulation.get_elapsed_time() / simulation.get_time_limit()) * 100)
progress = min(progress, 100)
print('\r'*15 + 'progress: ' + str(progress).ljust(3) + '%', end='', flush=True)
if step_callback is not None:
step_callback()
# Update drawings
self._update_drawings()
# Render a new frame of the simulation
window.Render()
filter.Modified()
writer.Write()
self.add_event_handler(on_step, 'simulation_step')
self._drawings_display_info.hide()
# Start the simulation
self.start_simulation()
try:
# Perform the simulation
while simulation.is_running():
simulation._update(delta_t)
writer.End()
print()
print('completed ', flush=True)
if _is_ipython_avaliable and _is_notebook_environment:
return IPython.display.Video(filepath, embed=True, mimetype='video/ogg')
finally:
self.remove_event_handler(on_step)
self._drawings_display_info.show()
slider_widget = vtk.vtkSliderWidget()
slider_widget.SetInteractor(interactor)
slider_widget.SetRepresentation(slider_repres)
slider_widget.KeyPressActivationOff()
slider_widget.SetAnimationModeToAnimate()
slider_widget.SetEnabled(True)
slider_widget.AddObserver('InteractionEvent', observer)
return slider_widget, slider_repres
image_maker = vtk.vtkWindowToImageFilter()
image_maker.SetInput(renderer_window)
recorder = vtk.vtkOggTheoraWriter()
recorder.SetQuality(2)
recorder.SetRate(25)
recorder.SetFileName('xout.avi')
recorder.SetInputConnection(image_maker.GetOutputPort())
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(image_maker.GetOutputPort())
class InputObserver():
def __init__(self, times, slider_repres):
self._stimes = set(times)
self._opacity = 1.0
self._time_step = (max(self._stimes) - min(self._stimes)) \
/ len(self._stimes)
slider_repres.SetLabelHeight(0.02)
slider_widget = vtk.vtkSliderWidget()
slider_widget.SetInteractor(interactor)
slider_widget.SetRepresentation(slider_repres)
slider_widget.KeyPressActivationOff()
slider_widget.SetAnimationModeToAnimate()
slider_widget.SetEnabled(True)
slider_widget.AddObserver('InteractionEvent', observer)
return slider_widget, slider_repres
image_maker = vtk.vtkWindowToImageFilter()
image_maker.SetInput(renderer_window)
recorder = vtk.vtkOggTheoraWriter()
recorder.SetQuality(2)
recorder.SetRate(25)
recorder.SetFileName('xout.avi')
recorder.SetInputConnection(image_maker.GetOutputPort())
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(image_maker.GetOutputPort())
class InputObserver():
def __init__(self, times, slider_repres):
self._stimes = set(times)
self._opacity = 1.0
self._time_step = (max(self._stimes) - min(self._stimes)) \
/ len(self._stimes)
self._time = min(times)
def save_nii2avi(niipath='test_0.nii.gz',
Save_file_name="moive.mp4",
Time_Loop=20,
Avi_rate=5,
Angle=20):
# read a NIFTI file
reader = vtk.vtkNIFTIImageReader()
reader.SetFileName(niipath)
reader.TimeAsVectorOn()
reader.Update()
def getActor(b1, b2, color):
threshold = vtk.vtkImageThreshold()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdBetween(b1, b2)
threshold.ReplaceInOn()
threshold.SetInValue(0) # set all values below 400 to 0
threshold.ReplaceOutOn()
threshold.SetOutValue(1) # set all values above 400 to 1
threshold.Update()
dmc = vtk.vtkDiscreteMarchingCubes()
dmc.SetInputConnection(threshold.GetOutputPort())
dmc.GenerateValues(1, 1, 1)
dmc.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(dmc.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(color)
return actor
actor_1 = getActor(200, 206, vtk_clr.banana)
actor_2 = getActor(410, 430, vtk_clr.blue_light)
actor_3 = getActor(490, 510, vtk_clr.cadmium_lemon)
actor_4 = getActor(540, 560, vtk_clr.chrome_oxide_green)
actor_5 = getActor(590, 610, vtk_clr.rose_madder)
actor_6 = getActor(810, 830, vtk_clr.green_dark)
actor_7 = getActor(840, 860, vtk_clr.purple)
#Renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(0, 0, 0)
#RenderWindow
renwin = vtk.vtkRenderWindow()
renwin.AddRenderer(renderer)
#assemble all part
assembly = vtk.vtkAssembly()
assembly.AddPart(actor_1)
assembly.AddPart(actor_2)
assembly.AddPart(actor_3)
assembly.AddPart(actor_4)
assembly.AddPart(actor_5)
assembly.AddPart(actor_6)
assembly.AddPart(actor_7)
assembly.SetOrigin(0, 0, 0)
#Add outline assenble actor
renderer.AddActor(assembly)
renwin.SetSize(600, 600)
# interactor = vtk.vtkRenderWindowInteractor()
# interactor.SetRenderWindow(renwin)
# interactor.Initialize()
renwin.Render()
#convert console to movie
imageFilter = vtk.vtkWindowToImageFilter()
imageFilter.SetInput(renwin)
moviewriter = vtk.vtkOggTheoraWriter()
moviewriter.SetInputConnection(imageFilter.GetOutputPort())
moviewriter.SetFileName(Save_file_name)
moviewriter.Start()
moviewriter.SetRate(Avi_rate)
for i in range(Time_Loop):
renderer.GetActiveCamera().Azimuth(Angle)
imageFilter.Modified()
moviewriter.Write()
moviewriter.End()
import vtk
def cb(interactor, event):
global plane_actor
plane_actor.RotateZ(0.1)
ren = vtk.vtkRenderer()
windowToImageFilter = vtk.vtkWindowToImageFilter()
iren = vtk.vtkRenderWindowInteractor()
moviewriter = vtk.vtkOggTheoraWriter()
class MyInteractorStyle(vtk.vtkInteractorStyleTrackballCamera):
def __init__(self, parent=None):
self.AddObserver("MiddleButtonPressEvent", self.middleButtonPressEvent)
self.AddObserver("MiddleButtonReleaseEvent", self.middleButtonReleaseEvent)
def middleButtonPressEvent(self, obj, event):
print("Middle Button pressed")
t = ren.GetActiveCamera()
for i in range(360):
t.Azimuth(1)
iren.GetRenderWindow().Render()
windowToImageFilter.Modified()
moviewriter.Write()
self.OnMiddleButtonDown()
return
