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