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)