def test_scene_screenshot(name, scale):
s = Scene(screenshots_folder="tests/screenshots")
s.screenshot(name=name, scale=scale)
shutil.rmtree("tests/screenshots")
s.render(interactive=False)
del s
def test_add_from_files():
scene = Scene()
obj = scene.add("tests/files/CC_134_1_ch1inj.obj", color="red")
assert isinstance(obj, Actor)
scene.render(interactive=False)
del scene
def test_set_camera():
s = Scene()
s.render(interactive=False)
cam = s.plotter.camera
set_camera(s, cam)
set_camera(s, "sagittal")
def test_volume():
scene = Scene(inset=False, root=True)
data = np.load("examples/data/volume.npy")
scene.add(Volume(data, voxel_size=200, as_surface=False, c="Reds"))
scene.add(Volume(data, voxel_size=200, as_surface=True, c="Reds", mode=2))
scene.render(interactive=False)
def test_points_density():
s = Scene(title="BR")
mos = s.add_brain_region("MOs", alpha=0.0)
coordinates = get_n_random_points_in_region(mos, 2000)
pd = s.add(PointsDensity(coordinates))
assert isinstance(pd, Actor)
s.render(interactive=False)
del s
def test_cylinder():
s = Scene(title="BR")
th = s.add_brain_region("TH")
s.add(Cylinder(th, s.root))
s.add(Cylinder(th.centerOfMass(), s.root))
s.render(interactive=False)
del s
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 test_scene_specials():
scene = Scene()
print(scene)
assert (
str(scene)
== f"A `brainrender.scene.Scene` with {len(scene.actors)} actors."
)
scene.content
scene.render(interactive=False)
del scene
def test_atlas_plane(pos, plane, norm):
s = Scene()
p1 = s.atlas.get_plane(plane=plane, pos=pos, norm=norm, sx=1, sy=11)
p2 = s.atlas.get_plane(plane=plane, pos=pos, norm=norm)
assert isinstance(p1, Actor)
assert isinstance(p2, Actor)
s.render(interactive=False)
del s
def test_streamlines():
s = Scene(title="BR")
streams = get_streamlines_for_region("TH", force_download=False)
s.add(Streamlines(streams[0]))
s.add(*make_streamlines(*streams[1:3]))
with pytest.raises(TypeError):
Streamlines([1, 2, 3])
s.render(interactive=False)
del s
def test_ruler_from_surface():
s = Scene(title="BR")
th = s.add_brain_region("TH", hemisphere="left")
s.add(
ruler_from_surface(th.centerOfMass(),
s.root,
unit_scale=0.01,
units="mm"))
s.render(interactive=False)
del s
def test_ruler():
s = Scene(title="BR")
th = s.add_brain_region("TH", hemisphere="left")
mos = s.add_brain_region("MOs", hemisphere="right")
s.add(
ruler(th.centerOfMass(),
mos.centerOfMass(),
unit_scale=0.01,
units="mm"))
s.render(interactive=False)
del s
def test_brain_regions():
scene = Scene()
th = scene.add_brain_region("TH")
assert scene.actors[-1] == th
assert isinstance(th, Actor)
regs = scene.add_brain_region("MOs", "CA1")
assert isinstance(regs, list)
assert len(regs) == 2
noone = scene.add_brain_region("what is this")
assert noone is None
a1 = scene.add_brain_region("TH", hemisphere="left")
a2 = scene.add_brain_region("CA1", hemisphere="right")
assert isinstance(a1, Actor)
assert isinstance(a2, Actor)
scene.render(interactive=False)
del scene
def test_gebe_expression_api(geapi):
s = Scene(title="BR")
geapi.get_gene_id_by_name(gene)
expids = geapi.get_gene_experiments(gene)
data = geapi.get_gene_data(gene, expids[0], use_cache=True)
# make actor
gene_actor = geapi.griddata_to_volume(
data, min_quantile=90, cmap="inferno"
)
assert isinstance(gene_actor, Actor)
assert gene_actor.name == gene
assert gene_actor.br_class == "Gene Data"
s.add(gene_actor)
s.render(interactive=False)
del s
def test_scene_slice():
s = Scene()
s.add_brain_region("TH")
s.slice("frontal")
ret = s.slice("frontal",)
assert ret is None
s.slice("sagittal", close_actors=True)
s = Scene()
th = s.add_brain_region("TH")
plane = s.atlas.get_plane(pos=[1999, 1312, 3421], norm=[1, -1, 2])
s.slice(plane, actors=th)
ret = s.slice(plane, actors=[th, s.root],)
s.render(interactive=False)
del s
def test_points_working():
s = Scene(title="BR")
act = Points(np.load("tests/files/random_cells.npy"))
act2 = Points("tests/files/random_cells.npy", colors="k")
act3 = Points("tests/files/random_cells.npy", name="test")
assert act3.name == "test"
s.add(act)
s.add(act2)
point = Point([100, 233, 422])
s.add(point)
assert isinstance(point, Actor)
assert isinstance(act, Actor)
assert isinstance(act2, Actor)
assert isinstance(act3, Actor)
assert point.name == "Point"
s.render(interactive=False)
del s
def test_scene_render():
scene = Scene()
scene.add_brain_region("TH")
scene.render(interactive=False, zoom=1.4)
scene.render(
interactive=False,
camera=dict(
pos=(
10705.845660949382,
7435.678067378925,
-36936.3695486442,
),
viewup=(
-0.0050579179155257475,
-0.9965615097647067,
-0.08270172139591858,
),
clippingRange=(30461.81976236306, 58824.38622122339),
),
)
def test_scene_creation():
scene = Scene(root=False)
scene.root
assert scene.root.alpha() == 0
scene = Scene(atlas_name="mpin_zfish_1um")
assert isinstance(scene.root, Actor)
noinset = Scene(inset=False, title="TEST")
noinset.root
noinset.render(interactive=False)
scene.render(interactive=False)
del scene
noinset.render(interactive=False)
del noinset
"""
This example shows how to add a label to a renderend actor
"""
from brainrender import Scene
from rich import print
from myterial import orange
from pathlib import Path
print(f"[{orange}]Running example: {Path(__file__).name}")
# crate a scene and add brain regions
scene = Scene()
th, mos = scene.add_brain_region("TH", "MOs")
scene.add_label(th, "TH")
scene.add_label(mos, "My region")
# render
scene.render()
from rich import print
from pathlib import Path
from brainrender import Scene
sys.path.append("./")
from paper.figures import INSET, SILHOUETTE
print("[bold red]Running: ", Path(__file__).name)
# camera settings
cam = {
"pos": (-20268, -6818, 14964),
"viewup": (0, -1, 0),
"clippingRange": (16954, 58963),
"focalPoint": (6489, 4329, -5556),
"distance": 35514,
}
# create scene
scene = Scene(inset=INSET, screenshots_folder="paper/screenshots")
scene.root._needs_silhouette = SILHOUETTE
# add brain regions
for reg, col in zip(("SCm", "SCs", "ZI"), (scmcol, scscol, zicol)):
scene.add_brain_region(reg, color=col, silhouette=SILHOUETTE)
# render
scene.render(zoom=1.75, camera=cam)
scene.screenshot(name="mouse_regions", scale=1)
# 1. load the data
print("Loading data")
data = imio.load.load_any(datafile)
# 2. aligned the data to the scene's atlas' axes
print("Transforming data")
scene = Scene(atlas_name="mpin_zfish_1um")
source_space = AnatomicalSpace(
"ira"
) # for more info: https://docs.brainglobe.info/bg-space/usage
target_space = scene.atlas.space
transformed_stack = source_space.map_stack_to(target_space, data)
# 3. create a Volume vedo actor and smooth
print("Creating volume")
vol = Volume(transformed_stack, origin=scene.root.origin()).medianSmooth()
# 4. Extract a surface mesh from the volume actor
print("Extracting surface")
SHIFT = [-20, 15, 30] # fine tune mesh position
mesh = (
vol.isosurface(threshold=20).c(blue_grey).decimate().clean().addPos(*SHIFT)
)
# 5. render
print("Rendering")
scene.add(mesh)
scene.render(zoom=13)
print("[bold red]Running: ", Path(__file__).name)
# define camera parmeters
cam = {
"pos": (5792, 431, 36893),
"viewup": (0, -1, 0),
"clippingRange": (39051, 53300),
"focalPoint": (5865, 4291, -8254),
"distance": 45311,
}
# make scene
scene = Scene(inset=INSET, screenshots_folder="paper/screenshots")
scene.add_brain_region("TH", alpha=0.2, silhouette=False, color=thcol)
# load cell coordinates and add as a Points actor
coords = np.load("paper/data/cell-detect-paper-cells.npy")
cells = scene.add(Points(coords, radius=30, colors=salmon))
# add a silhouette around the cells
scene.add_silhouette(cells, lw=1)
# slice scene with a sagittal plane
scene.slice("sagittal")
# render and save screenshotq
scene.render(interactive=True, camera="sagittal", zoom=2.6)
scene.screenshot(name="cellfinder_cells")
scene.close()
class App(Scene, UI, CameraControl, AddFromFile, RegionsControl,
ActorsControl):
actors = {} # stores actors and status
camera_orientation = None # used to manually set camera orientation
def __init__(self, *args, atlas_name=None, axes=None, **kwargs):
"""
Initialise the qtpy app and the brainrender scene.
Arguments:
----------
atlas_name: str/None. Name of the brainglobe atlas to use
axes: bool. If true axes are shown in the brainrender render
"""
# Initialize parent classes
self.scene = Scene(*args, atlas_name=atlas_name, **kwargs)
UI.__init__(self, *args, **kwargs)
CameraControl.__init__(self)
AddFromFile.__init__(self)
RegionsControl.__init__(self)
ActorsControl.__init__(self)
# Setup brainrender plotter
self.axes = axes
self.atuple = namedtuple("actor", "mesh, is_visible, color, alpha")
self.setup_plotter()
self._update()
self.scene._get_inset()
# Setup widgets functionality
self.actors_list.itemDoubleClicked.connect(
self.actor_list_double_clicked)
self.actors_list.clicked.connect(self.actor_list_clicked)
buttons_funcs = dict(
add_brain_regions=self.open_regions_dialog,
add_from_file=self.add_from_file_object,
add_cells=self.add_from_file_cells,
show_structures_tree=self.toggle_treeview,
take_screenshot=self.take_screenshot,
reset=self.reset_camera,
top=self.move_camera_top,
side1=self.move_camera_side1,
side2=self.move_camera_side2,
front=self.move_camera_front,
)
for btn, fun in buttons_funcs.items():
self.buttons[btn].clicked.connect(fun)
self.treeView.clicked.connect(self.add_region_from_tree)
self.alpha_textbox.textChanged.connect(self.update_actor_properties)
self.color_textbox.textChanged.connect(self.update_actor_properties)
def take_screenshot(self):
self._update()
self.scene.plotter.render()
# Get savename
self.scene.screenshots_folder.mkdir(exist_ok=True)
savename = str(self.scene.screenshots_folder / "brainrender_gui")
savename += (f'_{datetime.datetime.now().strftime("%Y%m%d_%H%M%S")}' +
".png")
print(f"\nSaving screenshot at {savename}\n")
self.scene.screenshot(name=savename)
# show success message
dialog = ScreenshotModal(self, self.palette)
dialog.exec()
# ------------------------------ Toggle treeview ----------------------------- #
def toggle_treeview(self):
"""
Method for the show structures tree button.
It toggles the visibility of treeView widget
and adjusts the button's text accordingly.
"""
if not self.treeView.isHidden():
self.buttons["show_structures_tree"].setText(
"Show structures tree")
else:
self.buttons["show_structures_tree"].setText(
"Hide structures tree")
self.treeView.setHidden(not self.treeView.isHidden())
# ------------------------------- Initial setup ------------------------------ #
def setup_plotter(self):
"""
Changes the scene's default plotter
with one attached to the qtWidget in the
pyqt application.
"""
# Get embedded plotter
new_plotter = Plotter(qtWidget=self.vtkWidget)
self.scene.plotter = new_plotter
# Get axes
if self.axes:
self.axes = self._make_axes()
# self.scene.add_actor(ax)
else:
self.axes = None
# Fix camera
set_camera(self.scene, self.scene.plotter.camera)
# ---------------------------------- Update ---------------------------------- #
def _update_actors(self):
"""
All actors that are part of the scene are stored
in a dictionary with key as the actor name and
value as a 4-tuple with (Mesh, is_visible, color, alpha).
`is_visible` is a bool that determines if the
actor should be rendered
"""
for actor in self.scene.actors:
if actor is None:
continue
try:
if actor.name not in self.actors.keys():
self.actors[actor.name] = self.atuple(
actor, True, actor.mesh.color(), actor.mesh.alpha())
except AttributeError:
# the Assembly object representing the axes should be ignore
pass
def _update(self):
"""
Updates the scene's Plotter to add/remove
meshes
"""
if self.camera_orientation is not None:
# set_camera(self.scene, self.camera_orientation)
camera = self.camera_orientation
self.camera_orientation = None
else:
camera = get_camera_params(scene=self.scene)
self.scene.render(camera=camera)
# Get actors to render
self._update_actors()
to_render = [act for act in self.actors.values() if act.is_visible]
# Set actors look
meshes = [act.mesh.c(act.color).alpha(act.alpha) for act in to_render]
# Add axes
if self.axes is not None:
meshes.append(self.axes)
# update actors rendered
self.scene.plotter.show(
*meshes,
interactorStyle=0,
bg=brainrender.settings.BACKGROUND_COLOR,
)
# Fake a button press to force canvas update
self.scene.plotter.interactor.MiddleButtonPressEvent()
self.scene.plotter.interactor.MiddleButtonReleaseEvent()
# Update list widget
update_actors_list(self.actors_list, self.actors)
return meshes
# ----------------------------------- Close ---------------------------------- #
def onClose(self):
"""
Disable the interactor before closing to prevent it from trying to act on a already deleted items
"""
self.vtkWidget.close()
scene.root._needs_silhouette = False
scene.root.alpha(0.5)
# add brain regions
pag = scene.add_brain_region("PAG", alpha=0.4, silhouette=False, color=pagcol)
scm = scene.add_brain_region("SCm", alpha=0.3, silhouette=False, color=scmcol)
# add neuron mesh
neuron = scene.add("paper/data/yulins_neuron.stl")
neuron.c(neuroncol)
# add sphere at soma location
soma_pos = [9350.51912036, 2344.33986638, 5311.18297796]
point = scene.add(Point(soma_pos, color=neuroncol, radius=25))
scene.add_silhouette(point, lw=1, color="k")
scene.add_silhouette(neuron, lw=1, color="k")
# slice scene repeatedly to cut out region of interest
p = [9700, 1, 800]
plane = scene.atlas.get_plane(pos=p, plane="frontal")
scene.slice(plane, actors=[scm, pag, scene.root])
p = [11010, 5000, 5705]
plane = scene.atlas.get_plane(pos=p, norm=[0, -1, 0])
scene.slice(plane, actors=[scene.root])
# render
scene.render(zoom=9, camera=cam)
scene.screenshot(name="single_neuron")
scene.close()
# add meshes from file
files = [
"paper/data/CC_134_2_ch1inj.obj",
"paper/data/CC_134_1_ch1inj.obj",
]
colors = [
inj1col,
inj2col,
]
injections = [scene.add(f, color=c) for f, c in zip(files, colors)]
scene.add_silhouette(*injections, lw=2)
# add brain regions
scm = scene.add_brain_region("SCm",
alpha=0.4,
silhouette=False,
color=blue_grey_darker)
pag = scene.add_brain_region("PAG",
alpha=0.3,
silhouette=False,
color=blue_grey)
# make brain region as wireframe
scm.wireframe()
pag.wireframe()
# render
scene.render(camera=cam, zoom=3.5)
scene.screenshot(name="injection")
cun, grn, mos = scene.add_brain_region("CUN", "GRN", "MOs", alpha=0.7)
# CUN/GRN probe
tip[1] = tip[1] + scene.root.centerOfMass()[2]
top[1] = top[1] + scene.root.centerOfMass()[2]
top = top[[0, 2, 1]]
tip = tip[[0, 2, 1]]
scene.add(shapes.Cylinder(pos=[top, tip], c="k", r=50, alpha=1))
# MOs probe
mos_center = mos.centerOfMass() + np.array([1000, 0, -800])
for x in [-500, -1000, -1500, -2000]:
scene.add(
Cylinder(mos_center + np.array([x, 0, 0]),
scene.root,
color="k",
radius=50))
camera = {
"pos": (-6374, -5444, 26602),
"viewup": (0, -1, 0),
"clippingRange": (19433, 56931),
"focalPoint": (7830, 4296, -5694),
"distance": 36602,
}
scene.render(interactive=False, camera=camera)
scene.screenshot(name="probes")
scene.add_brain_region("TH", alpha=0.2, silhouette=True, color=salmon)
scene.add_brain_region("VISp", alpha=0.4, silhouette=False, color=[50, 2, 155])
scene.slice("sagittal")
# Set up a camera. Can use string, such as "sagittal".
# During render runtime, press "c" to print the current camera parameters.
camera = {
"pos": (8777, 1878, -44032),
"viewup": (0, -1, 0),
"clippingRange": (24852, 54844),
"focalPoint": (7718, 4290, -3507),
"distance": 40610,
}
zoom = 1.5
# If you only want a screenshot and don't want to move the camera
# around the scene, set interactive to False.
scene.render(interactive=False, camera=camera, zoom=zoom)
# Set the scale, which will be used for screenshot resolution.
# Any value > 1 increases resolution, the default is in brainrender.settings.
# It is easiest integer scales (non-integer can cause crashes).
scale = 2
# Take a screenshot - passing no name uses current time
# Screenshots can be also created during runtime by pressing "s"
scene.screenshot(name="example_brainrender_shot", scale=scale)
scene.close()
from brainrender import Scene
from brainrender import settings
from brainrender.atlas_specific import GeneExpressionAPI
settings.SHOW_AXES = False
scene = Scene(inset=False)
gene = "Gpr161"
geapi = GeneExpressionAPI()
expids = geapi.get_gene_experiments(gene)
data = geapi.get_gene_data(gene, expids[1])
gene_actor = geapi.griddata_to_volume(data, min_quantile=99, cmap="inferno")
act = scene.add(gene_actor)
ca1 = scene.add_brain_region("CA1", alpha=0.2, color="skyblue")
ca3 = scene.add_brain_region("CA3", alpha=0.5, color="salmon")
scene.add_silhouette(act)
scene.render(zoom=1.6)
def test_scene_render_simple():
scene = Scene()
scene.render(interactive=False)
def test_labels():
scene = Scene()
th = scene.add_brain_region("TH")
scene.add_label(th, "TH")
scene.render(interactive=False)
del scene
