class Render(Enhanced):
_axes_order_corrected = (
False # at first render the axes orders is corrected
)
def __init__(
self,
verbose,
display_inset,
camera,
screenshot_kwargs,
use_default_key_bindings,
):
"""
Creates and manages a Plotter instance
:param add_root: if False a rendered outline of the whole brain is added to the scene (default value None)
:param verbose: if False less feedback is printed to screen (default value True)
:param display_inset: if False the inset displaying the brain's outline is not rendered (but the root is added to the scene) (default value None)
:param camera: name of the camera parameters setting to use (controls the orientation of the rendered scene)
:param screenshot_kwargs: pass a dictionary with keys:
- "folder" -> str, path to folder where to save screenshots
- "name" -> str, filename to prepend to screenshots files
- "format" -> str, format of the screenshot
:param use_default_key_bindings: if True the defualt keybindings from vedo are used, otherwise
a custom function that can be used to take screenshots with the parameter above.
"""
Enhanced.__init__(self)
# Setup a few rendering options
self.verbose = verbose
self.display_inset = (display_inset if display_inset is not None else
brainrender.DISPLAY_INSET)
if vedosettings.notebookBackend == "k3d":
self.jupyter = True
else:
self.jupyter = False
if self.display_inset and self.jupyter:
if self.verbose:
print(
"Setting 'display_inset' to False as this feature is not \
available in juputer notebooks")
self.display_inset = False
# Camera parameters
self.camera = get_scene_camera(camera, self.atlas)
# Create vedo plotter
self.plotter = Plotter(**get_scene_plotter_settings(
self.jupyter, self.atlas, self.verbose))
if brainrender.AXES_STYLE == 7 and brainrender.SHOW_AXES:
self.make_custom_axes = True # to be made at render
else:
self.make_custom_axes = False
self.screenshot_kwargs = screenshot_kwargs
if not use_default_key_bindings:
self.plotter.keyPressFunction = self.keypress
self.verbose = False
if not brainrender.SCREENSHOT_TRANSPARENT_BACKGROUND:
vedosettings.screenshotTransparentBackground = False
vedosettings.useFXAA = True
def _make_custom_axes(self):
"""
When using `ruler` axes (vedy style 7), we need to
customize them a little bit, this function takes care of it.
"""
raise NotImplementedError(
"Currently ony AXES_STYLE=1 is supported, sorry")
# Get plotter and axes color
plt = self.plotter
c = (0.9, 0.9, 0.9)
if np.sum(plt.renderer.GetBackground()) > 1.5:
c = (0.1, 0.1, 0.1)
bounds = [
item for sublist in self.atlas._root_bounds for item in sublist
]
rulax = buildRulerAxes(
bounds,
c=c,
units="μm",
xtitle="AP - ",
ytitle="DV - ",
ztitle="LR - ",
precision=1,
labelRotation=0,
axisRotation=90,
xycross=False,
)
rulax.UseBoundsOff()
rulax.PickableOff()
plt.renderer.AddActor(rulax)
plt.axes_instances[0] = rulax
return
def _correct_axes(self):
"""
When the scene is first rendered, a transform matrix
is applied to each actor's points to correct orientation
mismatches: https://github.com/brainglobe/bg-atlasapi/issues/73
"""
self._axes_order_corrected = True
# Flip every actor's orientation
_silhouettes = []
for actor in self.actors:
try:
_name = actor.name
except AttributeError:
""" not all scene objects will have a name """
continue
if _name != "silhouette":
try:
actor.applyTransform(mtx).reverse()
except AttributeError:
pass
else:
"""
Silhouettes don't transform properly,
we need to re-generate them
"""
_silhouettes.append(actor)
for sil in _silhouettes:
self.actors.pop(self.actors.index(sil))
self.add_silhouette(sil._original_mesh)
del sil
def apply_render_style(self):
if brainrender.SHADER_STYLE is None: # No style to apply
return
for actor in self.actors:
if actor is not None:
try:
if brainrender.SHADER_STYLE != "cartoon":
actor.lighting(style=brainrender.SHADER_STYLE)
else:
actor.lighting("off")
except AttributeError:
pass # Some types of actors such as Text 2D don't have this attribute!
def render(self,
interactive=True,
video=False,
camera=None,
zoom=None,
**kwargs):
"""
Takes care of rendering the scene
"""
self.apply_render_style()
if not video:
if (not self.jupyter
): # cameras work differently in jupyter notebooks?
if camera is None:
camera = self.camera
if isinstance(
camera,
(str, dict)): # otherwise assume that it's vtk.camera
camera = check_camera_param(camera)
set_camera(self, camera)
if interactive and self.verbose:
if not self.jupyter:
print(
f"\n\n[{mocassin}]Rendering scene.\n Press [{orange}]'q'[/{orange}] to Quit"
)
elif self.jupyter:
print(
f"[{mocassin}]The scene is ready to render in your jupyter notebook"
)
self._get_inset()
if zoom is None and not video:
zoom = 1.2 if brainrender.WHOLE_SCREEN else 1.5
# Make mesh labels follow the camera
if not self.jupyter:
for txt in self.actors_labels:
txt.followCamera(self.plotter.camera)
self.is_rendered = True
args_dict = dict(
interactive=interactive,
zoom=zoom,
bg=brainrender.BACKGROUND_COLOR,
axes=self.plotter.axes,
)
if video:
args_dict["offscreen"] = True
if self.make_custom_axes:
self._make_custom_axes()
self.make_custom_axes = False
# Correct axes orientations
if not self._axes_order_corrected:
self._correct_axes()
show(*self.actors, *self.actors_labels, **args_dict)
def close(self):
closePlotter()
def export_for_web(self, filepath="brexport.html"):
"""
This function is used to export a brainrender scene
for hosting it online. It saves an html file that can
be opened in a web browser to show an interactive brainrender scene
"""
if not filepath.endswith(".html"):
raise ValueError("Filepath should point to a .html file")
# prepare settings
vedosettings.notebookBackend = "k3d"
# Create new plotter and save to file
plt = Plotter()
plt.add(self.actors)
plt = plt.show(interactive=False)
plt.camera[-2] = -1
if self.verbose:
print(
"Ready for exporting. Exporting scenes with many actors might require a few minutes"
)
with open(filepath, "w") as fp:
fp.write(plt.get_snapshot())
if self.verbose:
print(
f"The brainrender scene has been exported for web. The results are saved at {filepath}"
)
# Reset settings
vedosettings.notebookBackend = None
self.jupyter = False
# ---------------------------------------------------------------------------- #
# USER INTERACTION #
# ---------------------------------------------------------------------------- #
def keypress(self, key):
if key == "s":
self.take_screenshot()
elif key == "q":
self.close()
elif key == "c":
print(f"Camera parameters:\n{get_camera_params(scene=self)}")
def take_screenshot(self,
screenshots_folder=None,
screenshot_name=None,
scale=None):
"""
:param screenshots_folder: folder where the screenshot will be saved
:param screenshot_name: name of the saved file
:param scale: int, upsampling factor over screen resolution. Increase to export
higher quality images
"""
if screenshots_folder is None:
screenshots_folder = Path(
self.screenshot_kwargs.get(
"folder", brainrender.DEFAULT_SCREENSHOT_FOLDER))
screenshots_folder.mkdir(exist_ok=True)
if screenshot_name is None:
name = self.screenshot_kwargs.get("name", "screenshot")
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
file_format = self.screenshot_kwargs.get("format", ".png")
screenshot_name = f"{name}_{timestamp}.{file_format}"
if not self.is_rendered:
print(
"You need to render the scene before you can take a screenshot"
)
return
if brainrender.SCREENSHOT_TRANSPARENT_BACKGROUND:
warnings.warn(
"BRAINRENDER - settings: screenshots are set to have transparent background. Set the parameter 'SCREENSHOT_TRANSPARENT_BACKGROUND' to False if you'd prefer a not transparent background"
)
savename = str(screenshots_folder / screenshot_name)
print(f"\nSaving new screenshot at {savename}\n")
self.plotter.screenshot(filename=savename, scale=scale)
return savename
class Render:
is_rendered = False
plotter = None
axes_names = ("AP", "DV", "LR")
axes_lookup = {"x": "AP", "y": "DV", "z": "LR"}
axes_indices = {"AP": 0, "DV": 1, "LR": 2}
def __init__(self):
"""
Backend for Scene, handles all rendering and exporting
related tasks.
"""
self._get_plotter()
def _get_plotter(self):
"""
Make a vedo plotter with
fancy axes and all
"""
self.plotter = Plotter(
axes=self._make_axes() if settings.SHOW_AXES else None,
pos=(0, 0),
title="brainrender",
bg=settings.BACKGROUND_COLOR,
offscreen=settings.OFFSCREEN,
size="full" if settings.WHOLE_SCREEN else "auto",
)
self.plotter.keyPressFunction = self.keypress
def _make_axes(self):
"""
Returns a dictionary with axes
parameters for the vedo plotter
"""
ax_idx = self.atlas.space.axes_order.index("frontal")
# make acustom axes dict
atlas_shape = np.array(self.atlas.metadata["shape"]) * np.array(
self.atlas.metadata["resolution"]
)
z_range = np.array([-atlas_shape[2], 0])
z_ticks = [
(-v, str(np.abs(v).astype(np.int32)))
for v in np.linspace(
0,
atlas_shape[ax_idx],
10,
)
]
if self.atlas.atlas_name == "allen_human_500um":
z_range = None
z_ticks = None
logger.debug(
"RENDER: manually forcing axes size for human atlas, atlas needs fixing"
)
# make custom axes dict
axes = dict(
axesLineWidth=3,
tipSize=0,
xtitle="AP (μm)",
ytitle="DV (μm)",
ztitle="LR (μm)",
textScale=0.8,
xTitleRotation=180,
zrange=z_range,
zValuesAndLabels=z_ticks,
xyGrid=False,
yzGrid=False,
zxGrid=False,
xUseBounds=True,
yUseBounds=True,
zUseBounds=True,
xLabelRotation=180,
yLabelRotation=180,
zLabelRotation=90,
)
return axes
def _prepare_actor(self, actor):
"""
When an actor is first rendered, a transform matrix
is applied to its points to correct axes orientation
mismatches: https://github.com/brainglobe/bg-atlasapi/issues/73
Once an actor is 'corrected' it spawns labels and silhouettes as needed
"""
# Flip every actor's orientation
if not actor._is_transformed:
try:
actor._mesh = actor.mesh.clone()
actor._mesh.applyTransform(mtx)
except AttributeError: # some types of actors dont trasform
actor._is_transformed = True
else:
try:
actor.mesh.reverse()
except AttributeError: # Volumes don't have reverse
pass
actor._is_transformed = True
# Add silhouette and labels
if actor._needs_silhouette and not self.backend:
self.plotter.add(actor.make_silhouette().mesh)
if actor._needs_label and not self.backend:
self.labels.extend(actor.make_label(self.atlas))
def _apply_style(self):
"""
Sets the rendering style for each mesh
"""
for actor in self.clean_actors:
if settings.SHADER_STYLE != "cartoon":
style = settings.SHADER_STYLE
else:
if self.backend: # notebook backend
print(
'Shader style "cartoon" cannot be used in a notebook'
)
style = "off"
try:
actor.mesh.reverse() # flip normals
actor.mesh.lighting(style=style)
actor._mesh.reverse()
actor._mesh.lighting(style=style)
except AttributeError:
pass
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 close(self):
closePlotter()
def export(self, savepath):
"""
Exports the scene to a .html
file for online renderings.
:param savepath: str, Path to a .html file to save the export
"""
logger.debug(f"Exporting scene to {savepath}")
_backend = self.backend
if not self.is_rendered:
self.render(interactive=False)
path = Path(savepath)
if path.suffix != ".html":
raise ValueError("Savepath should point to a .html file")
# prepare settings
vsettings.notebookBackend = "k3d"
# Create new plotter and save to file
plt = Plotter()
plt.add(self.renderables)
plt = plt.show(interactive=False)
plt.camera[-2] = -1
with open(path, "w") as fp:
fp.write(plt.get_snapshot())
print(
f"The brainrender scene has been exported for web. The results are saved at {path}"
)
# Reset settings
vsettings.notebookBackend = None
self.backend = _backend
return str(path)
def screenshot(self, name=None, scale=None):
"""
Takes a screenshot of the current view
and save it to file.
Screenshots are saved in `screenshots_folder`
(see Scene)
:param name: str, name of png file
:param scale: float, >1 for higher resolution
"""
if not self.is_rendered:
self.render(interactive=False)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
name = name or f"brainrender_screenshot_{timestamp}"
if ".png" not in name:
name += ".png"
scale = scale or settings.SCREENSHOT_SCALE
print(f"\nSaving new screenshot at {name}\n")
savepath = str(self.screenshots_folder / name)
logger.debug(f"Saving scene at {savepath}")
self.plotter.screenshot(filename=savepath, scale=scale)
return savepath
def _print_camera(self):
pms = get_camera_params(scene=self)
focal = pms.pop("focalPoint", None)
dst = pms.pop("distance", None)
names = [
f"[green bold] '{k}'[/green bold]: [{amber}]{v},"
for k, v in pms.items()
]
print(
f"[{deep_purple_light}]Camera parameters:",
f"[{orange}] {{",
*names,
f"[{orange}] }}",
f"[{deep_purple_light}]Additional, (optional) parameters:",
f"[green bold] 'focalPoint'[/green bold]: [{amber}]{focal},",
f"[green bold] 'distance'[/green bold]: [{amber}]{dst},",
sep="\n",
)
def keypress(self, key): # pragma: no cover
"""
Hanles key presses for interactive view
-s: take's a screenshot
-q: closes the window
-c: prints the current camera parameters
"""
if key == "s":
self.screenshot()
elif key == "q" or key == "Esc":
self.close()
elif key == "c":
self._print_camera()
class Render:
transform_applied = False
is_rendered = False
plotter = None
def __init__(self):
"""
Backend for Scene, handles all rendering and exporting
related tasks.
"""
return
def _get_plotter(self):
# Make a vedo plotter
self.plotter = Plotter(
axes=self._make_axes() if settings.SHOW_AXES else None,
pos=(0, 0),
title="brainrender",
bg=settings.BACKGROUND_COLOR,
offscreen=settings.OFFSCREEN,
size="full" if settings.WHOLE_SCREEN else "auto",
)
self.plotter.keyPressFunction = self.keypress
def _make_axes(self):
"""
Returns a dictionary with axes
parameters for the vedo plotter
"""
ax_idx = self.atlas.space.axes_order.index("frontal")
# make acustom axes dict
atlas_shape = np.array(self.atlas.metadata["shape"]) * np.array(
self.atlas.metadata["resolution"])
z_ticks = [(-v, str(np.abs(v).astype(np.int32))) for v in np.linspace(
0,
atlas_shape[ax_idx],
10,
)]
# make custom axes dict
axes = dict(
axesLineWidth=3,
tipSize=0,
xtitle="AP (μm)",
ytitle="DV (μm)",
ztitle="LR (μm)",
textScale=0.8,
xTitleRotation=0,
xFlipText=True,
zrange=np.array([-atlas_shape[2], 0]),
zValuesAndLabels=z_ticks,
xyGrid=False,
yzGrid=False,
zxGrid=False,
)
return axes
def _correct_axes(self):
"""
When an actor is first rendered, a transform matrix
is applied to its points to correct axes orientation
mismatches: https://github.com/brainglobe/bg-atlasapi/issues/73
Once an actor is 'corrected' it spawns labels and silhouettes as needed
"""
self.transform_applied = True
# Flip every actor's orientation
for actor in self.clean_actors + self.labels:
if not actor._is_transformed:
actor.mesh.applyTransform(mtx).reverse()
actor._is_transformed = True
if actor._needs_silhouette:
self.actors.append(actor.make_silhouette())
if actor._needs_label:
self.labels.extend(actor.make_label(self.atlas))
def _apply_style(self):
"""
Sets the rendering style for each mesh
"""
for actor in self.clean_actors:
if settings.SHADER_STYLE != "cartoon":
actor.mesh.lighting(style=settings.SHADER_STYLE)
else:
actor.mesh.lighting("off")
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 close(self):
closePlotter()
def export(self, savepath):
"""
Exports the scene to a .html
file for online renderings.
:param savepath: str, Path to a .html file to save the export
"""
_jupiter = self.jupyter
if not self.is_rendered:
self.render(interactive=False)
path = Path(savepath)
if path.suffix != ".html":
raise ValueError("Savepath should point to a .html file")
# prepare settings
vsettings.notebookBackend = "k3d"
# Create new plotter and save to file
plt = Plotter()
plt.add(self.renderables)
plt = plt.show(interactive=False)
plt.camera[-2] = -1
with open(path, "w") as fp:
fp.write(plt.get_snapshot())
print(
f"The brainrender scene has been exported for web. The results are saved at {path}"
)
# Reset settings
vsettings.notebookBackend = None
self.jupyter = _jupiter
return str(path)
def screenshot(self, name=None, scale=None):
"""
Takes a screenshot of the current view
and save it to file.
Screenshots are saved in `screenshots_folder`
(see Scene)
:param name: str, name of png file
:param scale: float, >1 for higher resolution
"""
if not self.is_rendered:
self.render(interactive=False)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
name = name or f"brainrender_screenshot_{timestamp}"
if ".png" not in name:
name += ".png"
scale = scale or settings.SCREENSHOT_SCALE
print(f"\nSaving new screenshot at {name}\n")
savepath = str(self.screenshots_folder / name)
self.plotter.screenshot(filename=savepath, scale=scale)
return savepath
def _print_camera(self):
pms = get_camera_params(scene=self)
focal = pms.pop("focalPoint", None)
dst = pms.pop("distance", None)
names = [
f"[green bold] '{k}'[/green bold]: [{amber}]{v},"
for k, v in pms.items()
]
print(
f"[{deep_purple_light}]Camera parameters:",
f"[{orange}] {{",
*names,
f"[{orange}] }}",
f"[{deep_purple_light}]Additional, (optional) parameters:",
f"[green bold] 'focalPoint'[/green bold]: [{amber}]{focal},",
f"[green bold] 'distance'[/green bold]: [{amber}]{dst},",
sep="\n",
)
def keypress(self, key): # pragma: no cover
"""
Hanles key presses for interactive view
-s: take's a screenshot
-q: closes the window
-c: prints the current camera parameters
"""
if key == "s":
self.screenshot()
elif key == "q" or key == "Esc":
self.close()
elif key == "c":
self._print_camera()
class Render:
def __init__(
self,
verbose,
display_inset,
camera,
screenshot_kwargs,
use_default_key_bindings,
):
"""
Creates and manages a Plotter instance
:param add_root: if False a rendered outline of the whole brain is added to the scene (default value None)
:param verbose: if False less feedback is printed to screen (default value True)
:param display_inset: if False the inset displaying the brain's outline is not rendered (but the root is added to the scene) (default value None)
:param camera: name of the camera parameters setting to use (controls the orientation of the rendered scene)
:param screenshot_kwargs: pass a dictionary with keys:
- 'folder' -> str, path to folder where to save screenshots
- 'name' -> str, filename to prepend to screenshots files
:param use_default_key_bindings: if True the defualt keybindings from vedo are used, otherwise
a custom function that can be used to take screenshots with the parameter above.
"""
# Setup a few rendering options
self.verbose = verbose
self.display_inset = (display_inset if display_inset is not None else
brainrender.DISPLAY_INSET)
if vedosettings.notebookBackend == "k3d":
self.jupyter = True
else:
self.jupyter = False
if self.display_inset and self.jupyter:
print("Setting 'display_inset' to False as this feature is not \
available in juputer notebooks")
self.display_inset = False
# Camera parameters
self.camera = get_scene_camera(camera, self.atlas)
# Create vedo plotter
self.plotter = Plotter(**get_scene_plotter_settings(self.jupyter))
# SCreenshots and keypresses variables
self.screenshots_folder = Path(
screenshot_kwargs.pop("folder", self.atlas.output_screenshots))
self.screenshots_name = screenshot_kwargs.pop(
"name", brainrender.DEFAULT_SCREENSHOT_NAME)
if not use_default_key_bindings:
self.plotter.keyPressFunction = self.keypress
self.verbose = False
if not brainrender.SCREENSHOT_TRANSPARENT_BACKGROUND:
vedosettings.screenshotTransparentBackground = False
vedosettings.useFXAA = True
def apply_render_style(self):
if brainrender.SHADER_STYLE is None: # No style to apply
return
for actor in self.actors:
if actor is not None:
try:
if brainrender.SHADER_STYLE != "cartoon":
actor.lighting(style=brainrender.SHADER_STYLE)
else:
actor.lighting("off")
except AttributeError:
pass # Some types of actors such as Text 2D don't have this attribute!
def render(self,
interactive=True,
video=False,
camera=None,
zoom=None,
**kwargs):
"""
Takes care of rendering the scene
"""
self.apply_render_style()
if not video:
if (not self.jupyter
): # cameras work differently in jupyter notebooks?
if camera is None:
camera = self.camera
if isinstance(
camera,
(str, dict)): # otherwise assume that it's vtk.camera
camera = check_camera_param(camera)
set_camera(self, camera)
if interactive:
if self.verbose and not self.jupyter:
print(brainrender.INTERACTIVE_MSG)
elif self.jupyter:
print(
"The scene is ready to render in your jupyter notebook"
)
else:
print("\n\nRendering scene.\n Press 'q' to Quit")
self._get_inset()
if zoom is None and not video:
zoom = 1.85 if brainrender.WHOLE_SCREEN else 1.5
# Make mesh labels follow the camera
if not self.jupyter:
for txt in self.actors_labels:
txt.followCamera(self.plotter.camera)
self.is_rendered = True
args_dict = dict(
interactive=interactive,
zoom=zoom,
bg=brainrender.BACKGROUND_COLOR,
axes=self.plotter.axes,
)
if video:
args_dict["offscreen"] = True
show(*self.actors, *self.actors_labels, **args_dict)
def close(self):
closePlotter()
def export_for_web(self, filepath="brexport.html"):
"""
This function is used to export a brainrender scene
for hosting it online. It saves an html file that can
be opened in a web browser to show an interactive brainrender scene
"""
if not filepath.endswith(".html"):
raise ValueError("Filepath should point to a .html file")
# prepare settings
vedosettings.notebookBackend = "k3d"
# Create new plotter and save to file
plt = Plotter()
plt.add(self.actors)
plt = plt.show(interactive=False)
plt.camera[-2] = -1
print(
"Ready for exporting. Exporting scenes with many actors might require a few minutes"
)
with open(filepath, "w") as fp:
fp.write(plt.get_snapshot())
print(
f"The brainrender scene has been exported for web. The results are saved at {filepath}"
)
# Reset settings
vedosettings.notebookBackend = None
self.jupyter = False
# ---------------------------------------------------------------------------- #
# USER INTERACTION #
# ---------------------------------------------------------------------------- #
def keypress(self, key):
if key == "s":
self.take_screenshot()
elif key == "q":
self.close()
elif key == "c":
print(f"Camera parameters:\n{get_camera_params(scene=self)}")
def take_screenshot(self):
if not self.is_rendered:
print(
"You need to render the scene before you can take a screenshot"
)
return
if brainrender.SCREENSHOT_TRANSPARENT_BACKGROUND:
warnings.warn(
"BRAINRENDER - settings: screenshots are set to have transparent background. Set the parameter 'SCREENSHOT_TRANSPARENT_BACKGROUND' to False if you'd prefer a not transparent background"
)
self.screenshots_folder.mkdir(exist_ok=True)
savename = str(self.screenshots_folder / self.screenshots_name)
savename += f'_{datetime.datetime.now().strftime("%Y%m%d_%H%M%S")}'
print(f"\nSaving screenshot at {savename}\n")
self.plotter.screenshot(filename=savename)
return savename
vmin=MINLAT,
vmax=MAXLAT).addScalarBar(
c='white',
title='LAT (ms) ',
titleFontSize=fontSize,
size=size)
a = 160
e = 0
r = 0
z = 1
verPoints = Points(vertices, r=5, c='white')
vplt = Plotter(N=1, axes=0, offscreen=True)
vplt.show(mesh, azimuth=a, elevation=e, roll=r, bg='black', zoom=z)
vplt.screenshot(filename=os.path.join(outSubDir, '0_mesh'),
returnNumpy=False).close()
vplt = Plotter(N=1, axes=0, offscreen=True)
vplt.show(mesh,
allLatPoints,
azimuth=a,
elevation=e,
roll=r,
bg='black',
zoom=z)
vplt.screenshot(filename=os.path.join(outSubDir, '0_all'),
returnNumpy=False).close()
vplt = Plotter(N=1, axes=0, offscreen=True)
vplt.show(mesh,
origLatPoints,
