def test_volume():
s = Scene(inset=False, root=True)
data = np.load("examples/data/volume.npy")
s.add(Volume(data, voxel_size=200, as_surface=False, c="Reds"))
s.add(Volume(data, voxel_size=200, as_surface=True, c="Reds", mode=2))
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))
del s
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_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_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_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)
del s
def test_neuron():
s = Scene(title="BR")
neuron = s.add(Neuron("tests/files/neuron1.swc"))
s.add(Neuron(Actor(neuron.mesh)))
s.add(Neuron(neuron.mesh))
Neuron(Sphere())
with pytest.raises(ValueError):
Neuron(1)
with pytest.raises(FileExistsError):
Neuron("tests/files/neuronsfsfs.swc")
with pytest.raises(NotImplementedError):
Neuron("tests/files/random_cells.h5")
del s
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_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"
del s
tip = np.array([5.507, -0.584, 6.489]) * 1000 + BREGMA
scene = Scene(
inset=False,
screenshots_folder=save_folder,
)
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),
# 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)
from brainrender import Scene
from brainrender.actors import ruler, ruler_from_surface
from rich import print
from myterial import orange
from pathlib import Path
print(f"[{orange}]Running example: {Path(__file__).name}")
scene = Scene(title="rulers")
th, mos = scene.add_brain_region("TH", "MOs", alpha=0.3)
# Get a ruler between the two regions
p1 = th.centerOfMass()
p2 = mos.centerOfMass()
rul1 = ruler(p1, p2, unit_scale=0.01, units="mm")
# Get a ruler between thalamus and brian surface
rul2 = ruler_from_surface(p1, scene.root, unit_scale=0.01, units="mm")
scene.add(rul1, rul2)
scene.render()
from brainrender import Scene
from brainrender.atlas_specific import get_streamlines_for_region
from brainrender.actors.streamlines import make_streamlines
# Create a brainrender scene
scene = Scene()
# Add brain regions
scene.add_brain_region("TH")
# Get stramlines data and add
streams = get_streamlines_for_region("TH")
scene.add(*make_streamlines(*streams, color="salmon", alpha=0.5))
# Render!
scene.render()
"""
Incrementally increase streamlines alpaha
"""
streams = scene.actors[8:]
for act in streams:
alpha = act.alpha()
act.alpha(alpha + 0.02)
# ------------------------------- create scene ------------------------------- #
scene = Scene(inset=INSET)
scene.root._needs_silhouette = SILHOUETTE
coords = np.load("paper/data/cell-detect-paper-cells.npy")
cells = scene.add(Points(coords, radius=30, colors=salmon))
rsp = scene.add_brain_region(
"RSP",
alpha=0.5,
silhouette=SILHOUETTE,
)
scene.add_brain_region(
"TH",
alpha=0.15,
color=[0.6, 0.6, 0.6],
silhouette=SILHOUETTE,
)
root_box(scene)
# get streamlines data
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)
from brainrender import Scene
from brainrender.actors import make_neurons, Neuron
from morphapi.api.mouselight import MouseLightAPI
# Create a brainrender scene
scene = Scene(title="neurons")
# Add a neuron from file
scene.add(Neuron("examples/data/neuron1.swc"))
# Download neurons data with morphapi
mlapi = MouseLightAPI()
neurons_metadata = mlapi.fetch_neurons_metadata(filterby="soma",
filter_regions=["MOs"])
to_add = [neurons_metadata[47], neurons_metadata[51]]
neurons = mlapi.download_neurons(to_add)
neurons = scene.add(*make_neurons(*neurons, neurite_radius=12))
# Render!
scene.render()
# Render probes
k = int(len(probes_locs) / 374.0)
for i in range(k):
points = probes_locs[i * 374:(i + 1) * 374]
color = "#adadac"
alpha = 1
LW = 1
spheres = Points(
points[["ccf_ap", "ccf_dv", "ccf_lr"]].values,
colors=color,
alpha=alpha,
radius=30,
)
spheres = scene.add(spheres, names="probe")
scene.add_silhouette(spheres, lw=LW)
# --------------------------------- Animation -------------------------------- #
anim = Animation(scene, "videos", "probes", size=None)
fps = 30
anim.add_keyframe(
0,
duration=7,
callback=spiker,
zoom=1.9,
cam1=cameras["three_quarters"],
cam2=cam0,
end=int(fps * 7),
prev=0,
screenshots_folder="paper/screenshots",
atlas_name="mpin_zfish_1um",
)
scene.root.alpha(0.2)
# get neurons data
api = MpinMorphologyAPI()
neurons_ids = api.get_neurons_by_structure(837)
neurons = api.load_neurons(neurons_ids)
# create neurons meshes
neurons = [
neuron.create_mesh(soma_radius=0.75, neurite_radius=1)
for neuron in neurons
][:N]
# color neurons parts and add to scene
for (neu_dict, neu) in track(neurons, total=N):
col = choice((c1, c2))
neuron = scene.add(neu_dict["axon"], alpha=1, color=col)
soma = scene.add(
Point(neu_dict["soma"].centerOfMass(), color=col, radius=8, alpha=1)
)
scene.add_silhouette(soma)
# render
scene.render(zoom=1.7, camera=cam)
scene.screenshot(name="zfish_neurons")
scene.close()
"viewup": (1, -1, -1),
"clippingRange": (1773, 4018),
"focalPoint": (478, 210, -296),
"distance": 2759,
}
# load cluster data and get cell coordinates
cluster_data = h5py.File("paper/data/zfish_rois_clusters.h5", "r")
cluster_ids = cluster_data["cluster_ids"][:]
roi_coords = cluster_data["coords"][:]
# create scene
scene = Scene(
inset=INSET,
screenshots_folder="paper/screenshots",
atlas_name="mpin_zfish_1um",
)
# add cells colored by cluster
colors = [c1, c2, c3]
for i, col in enumerate(colors):
rois_in_cluster = roi_coords[cluster_ids == i, :]
coords = pd.DataFrame(rois_in_cluster, columns=["x", "y", "z"]).values
pts = scene.add(Points(coords, colors=col, radius=2, alpha=1))
scene.add_silhouette(pts, lw=1)
# render
scene.render(camera=cam, zoom=2.5)
scene.screenshot(name="zfish_functional_clusters")
def get_n_random_points_in_region(region, N):
"""
Gets N random points inside (or on the surface) of a mes
"""
region_bounds = region.mesh.bounds()
X = np.random.randint(region_bounds[0], region_bounds[1], size=10000)
Y = np.random.randint(region_bounds[2], region_bounds[3], size=10000)
Z = np.random.randint(region_bounds[4], region_bounds[5], size=10000)
pts = [[x, y, z] for x, y, z in zip(X, Y, Z)]
ipts = region.mesh.insidePoints(pts).points()
return np.vstack(random.choices(ipts, k=N))
for N_cells in (10000, 100000, 1000000):
scene = Scene(inset=False)
coordinates = get_n_random_points_in_region(scene.root, N_cells)
with Timer(scene, name=f"Rendering {N_cells} cells"):
scene.add(actors.Points(coordinates))
scene = Scene(inset=False)
with Timer(scene, name=f"Slicing {N_cells} cells"):
scene.add(actors.Points(coordinates))
scene.slice("sagittal")
scene.close()
from brainrender import Scene
from rich import print
from myterial import orange
from pathlib import Path
print(f"[{orange}]Running example: {Path(__file__).name}")
# Create a brainrender scene
scene = Scene(title="Injection in SCm")
# Add brain SCm
scene.add_brain_region("SCm", alpha=0.2)
# Add from file
scene.add("examples/data/CC_134_1_ch1inj.obj", color="tomato")
# Render!
scene.render()
print(f"[{orange}]Running example: {Path(__file__).name}")
def get_n_random_points_in_region(region, N):
"""
Gets N random points inside (or on the surface) of a mes
"""
region_bounds = region.mesh.bounds()
X = np.random.randint(region_bounds[0], region_bounds[1], size=10000)
Y = np.random.randint(region_bounds[2], region_bounds[3], size=10000)
Z = np.random.randint(region_bounds[4], region_bounds[5], size=10000)
pts = [[x, y, z] for x, y, z in zip(X, Y, Z)]
ipts = region.mesh.insidePoints(pts).points()
return np.vstack(random.choices(ipts, k=N))
scene = Scene(title="Labelled cells")
# Get a numpy array with (fake) coordinates of some labelled cells
mos = scene.add_brain_region("MOs", alpha=0.15)
coordinates = get_n_random_points_in_region(mos, 2000)
# Add to scene
scene.add(Points(coordinates, name="CELLS", colors="steelblue"))
# render
scene.content
scene.render()
# create scene and makes sure root has silhouette
scene = Scene(inset=INSET, screenshots_folder="paper/screenshots")
scene.root._needs_silhouette = True
scene.root._silhouette_kwargs["lw"] = 1
# 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()
from brainrender.actors import Points, PointsDensity
def get_n_random_points_in_region(region, N):
"""
Gets N random points inside (or on the surface) of a mes
"""
region_bounds = region.bounds()
X = np.random.randint(region_bounds[0], region_bounds[1], size=10000)
Y = np.random.randint(region_bounds[2], region_bounds[3], size=10000)
Z = np.random.randint(region_bounds[4], region_bounds[5], size=10000)
pts = [[x, y, z] for x, y, z in zip(X, Y, Z)]
ipts = region.insidePoints(pts).points()
return np.vstack(random.choices(ipts, k=N))
scene = Scene(title="Labelled cells")
# Get a numpy array with (fake) coordinates of some labelled cells
mos = scene.add_brain_region("MOs", alpha=0.0)
coordinates = get_n_random_points_in_region(mos, 2000)
# Add to scene
scene.add(Points(coordinates, name="CELLS", colors="salmon"))
scene.add(PointsDensity(coordinates))
# render
scene.render()
"clippingRange": (22401, 34813),
"focalPoint": (7265, 2199, -5258),
"distance": 24256,
}
# create scene
scene = Scene(inset=False, screenshots_folder="paper/screenshots", root=True)
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])
BREGMA = np.array([5400, 0, 0]) # AP # DV # ML
top = np.array([4.136, -2.106, 0]) * 1000 + BREGMA # AP ML DV
tip = np.array([5.507, -0.584, 6.489]) * 1000 + BREGMA
scene = Scene()
cun, grn = scene.add_brain_region("CUN", "GRN", alpha=0.4)
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]]
print(f"Distance between tip and top: {np.linalg.norm(top-tip):.3f}")
scene.add(Point(top))
scene.add(Point(tip))
p = cun.centerOfMass()
p[2] -= 1400
scene.add(Point(p))
rul1 = ruler(tip, top, unit_scale=0.001, units="mm")
rul2 = ruler(tip, p, unit_scale=0.001, units="mm")
rul3 = ruler(p, top, unit_scale=0.001, units="mm")
scene.add(rul2, rul3)
scene.render()
"""
from brainrender import Scene
from brainrender import settings
from brainrender.actors import Cylinder
settings.SHOW_AXES = False
settings.WHOLE_SCREEN = False
from rich import print
from myterial import orange
from pathlib import Path
print(f"[{orange}]Running example: {Path(__file__).name}")
scene = Scene(inset=False, title="optic canula")
th = scene.add_brain_region(
"TH",
alpha=0.4,
)
# create and add a cylinder actor
actor = Cylinder(
th, # center the cylinder at the center of mass of th
scene.root, # the cylinder actor needs information about the root mesh
)
scene.add(actor)
scene.render(zoom=1.6)
"viewup": (0, -1, 0),
"clippingRange": (1703, 3984),
"focalPoint": (334, 200, -342),
"distance": 2660,
}
# create scene
scene = Scene(
atlas_name="mpin_zfish_1um",
inset=INSET,
screenshots_folder="paper/screenshots",
)
scene.root.alpha(0.2)
# add custom meshes from file, but don't show them (alpha=0)
m = scene.add("paper/data/T_AVG_nk1688CGt_GFP.obj", color=gene1_color, alpha=0)
m2 = scene.add("paper/data/T_AVG_brn3c_GFP.obj", color=gene2_color, alpha=0)
# adjust meshes position
for mesh in (m, m2):
mesh.mesh.addPos(dp_x=SHIFT)
# convert meshes to volumetric data showing gene expression density
vol1 = Volume(m.density(), as_surface=True, min_value=20000, cmap="Reds")
vol1.lw(1)
scene.add(vol1)
vol2 = Volume(m2.density(), as_surface=True, min_value=600, cmap="Blues")
vol2.lw(1)
scene.add(vol2)
