def test_get_camera_params(): s = Scene() s.render(interactive=False) cam = s.plotter.camera params = get_camera_params(scene=s) params2 = get_camera_params(camera=cam) check_camera_param(params) check_camera_param(params2)
def render(self, interactive=None, camera=None, zoom=1.75, **kwargs): """ Renders the scene. :param interactive: bool. If note settings.INTERACTIVE is used. If true the program's execution is stopped and users can interact with scene. :param camera: str, dict. If none the default camera is used. Pass a valid camera input to specify the camera position when the scene is rendered. :param zoom: float :param kwargs: additional arguments to pass to self.plotter.show """ # get vedo plotter if self.plotter is None: self._get_plotter() # Get camera if camera is None: camera = get_camera(settings.DEFAULT_CAMERA) else: camera = check_camera_param(camera) if not self.jupyter: camera = set_camera(self, camera) # Apply axes correction self._correct_axes() # Apply style self._apply_style() if self.inset and not self.jupyter and not self.is_rendered: self._get_inset() # render self.is_rendered = True if not self.jupyter: if interactive is None: interactive = settings.INTERACTIVE for txt in self.labels: txt.followCamera(self.plotter.camera) self.plotter.show( *self.renderables, interactive=interactive, zoom=zoom, bg=settings.BACKGROUND_COLOR, offscreen=settings.OFFSCREEN, camera=camera.copy(), interactorStyle=0, ) else: print( "Your scene is ready for rendering, use: `show(scene.renderables)`" )
def add_keyframe( self, time, duration=0, camera=None, zoom=None, interpol="sigma", callback=None, **kwargs, ): """ Add a keyframe to the video. :param time: float, time in seconds during the video at which the keyframe takes place. :param duration: float, if >0 the key frame is repeated every 5ms to go from start to start+duration :param zoom: camera zoom :param camera: dictionary of camera parameters :param interpol: str, if `sigma` or `linear` specifies the interpolation mode between key frames. :param callback: function which takes scene, current video frame and total number of frames in video as arguments. can be used to make stuff happen during a key frame (e.g. remove an actor) """ if camera is not None: camera = check_camera_param(camera) if time in self.keyframes.keys() and time > 0: print(f"[b {orange}]Keyframe {time} already exists, overwriting!") if zoom is None: previous_zoom = list(self.keyframes.values())[0]["zoom"] or 0 zoom = previous_zoom if not duration: self.keyframes[time] = dict( zoom=zoom, camera=camera, callback=callback, interpol=interpol, kwargs=kwargs, ) else: for time in np.arange(time, time + duration, 0.001): self.keyframes[time] = dict( zoom=zoom if time == 0 else None, camera=camera, callback=callback, interpol=interpol, kwargs=kwargs, )
def test_camera_params(): for camera in cameras: check_camera_param(camera)
def render( self, interactive=None, camera=None, zoom=None, update_camera=True, **kwargs, ): """ Renders the scene. :param interactive: bool. If note settings.INTERACTIVE is used. If true the program's execution is stopped and users can interact with scene. :param camera: str, dict. If none the default camera is used. Pass a valid camera input to specify the camera position when the scene is rendered. :param zoom: float, if None atlas default is used :param update_camera: bool, if False the camera is not changed :param kwargs: additional arguments to pass to self.plotter.show """ logger.debug( f"Rendering scene. Interactive: {interactive}, camera: {camera}, zoom: {zoom}" ) # get zoom zoom = zoom or self.atlas.zoom # get vedo plotter if self.plotter is None: self._get_plotter() # Get camera camera = camera or settings.DEFAULT_CAMERA if isinstance(camera, str): camera = get_camera(camera) else: camera = check_camera_param(camera) if camera["focalPoint"] is None: camera["focalPoint"] = self.root._mesh.centerOfMass() if not self.backend and camera is not None: camera = set_camera(self, camera) # Apply axes correction for actor in self.clean_actors: if not actor._is_transformed: self._prepare_actor(actor) self.plotter.add(actor.mesh) if actor._needs_silhouette or actor._needs_label: self._prepare_actor(actor) # add labels to the scene for label in self.labels: if label._is_added: continue else: label._mesh = label.mesh.clone() self._prepare_actor(label) self.plotter.add(label._mesh) label._is_added = True # Apply style self._apply_style() if self.inset and not self.is_rendered: self._get_inset() # render self.is_rendered = True if not self.backend: # not running in a python script if interactive is None: interactive = settings.INTERACTIVE for txt in self.labels: txt.followCamera(self.plotter.camera) self.plotter.show( interactive=interactive, zoom=zoom, bg=settings.BACKGROUND_COLOR, offscreen=settings.OFFSCREEN, camera=camera.copy() if update_camera else None, interactorStyle=0, rate=40, ) elif self.backend == "k3d": # pragma: no cover # Remove silhouettes self.remove(*self.get_actors(br_class="silhouette")) print( f"[{teal}]Your scene is ready for rendering, use:\n", Syntax("from vedo import show", lexer_name="python"), Syntax("vedo.show(*scene.renderables)", lexer_name="python"), sep="\n", ) else: # pragma: no cover print( f"[{teal}]Your scene is ready for rendering, use:\n", Syntax("from itkwidgets import view", lexer_name="python"), Syntax( "view(scene.plotter.show(*scene.renderables))", lexer_name="python", ), sep="\n", )
def render(self, interactive=None, camera=None, zoom=1.75, **kwargs): """ Renders the scene. :param interactive: bool. If note settings.INTERACTIVE is used. If true the program's execution is stopped and users can interact with scene. :param camera: str, dict. If none the default camera is used. Pass a valid camera input to specify the camera position when the scene is rendered. :param zoom: float :param kwargs: additional arguments to pass to self.plotter.show """ # get vedo plotter if self.plotter is None: self._get_plotter() # Get camera if camera is None: camera = get_camera(settings.DEFAULT_CAMERA) else: camera = check_camera_param(camera) if not self.backend and camera is not None: camera = set_camera(self, camera) # Apply axes correction self._prepare_actor() # Apply style self._apply_style() if self.inset and not self.is_rendered: self._get_inset() # render self.is_rendered = True if not self.backend: # not running in a python script if interactive is None: interactive = settings.INTERACTIVE for txt in self.labels: txt.followCamera(self.plotter.camera) self.plotter.show( *self.renderables, interactive=interactive, zoom=zoom, bg=settings.BACKGROUND_COLOR, offscreen=settings.OFFSCREEN, camera=camera.copy() if camera else None, interactorStyle=0, ) elif self.backend == "k3d": # pragma: no cover # Remove silhouettes self.remove(*self.get_actors(br_class="silhouette")) print( f"[{teal}]Your scene is ready for rendering, use:\n", Syntax("from vedo import show", lexer_name="python"), Syntax("vedo.show(*scene.renderables)", lexer_name="python"), sep="\n", ) else: # pragma: no cover print( f"[{teal}]Your scene is ready for rendering, use:\n", Syntax("from itkwidgets import view", lexer_name="python"), Syntax( "view(scene.plotter.show(*scene.renderables))", lexer_name="python", ), sep="\n", )