def test_tractography():
scene = Scene()
analyzer = ABA()
p0 = scene.get_region_CenterOfMass("ZI")
tract = analyzer.get_projection_tracts_to_target(p0=p0)
scene.add_tractography(tract, display_injection_structure=False, color_by="target_region",
VIP_regions=['MOs'], VIP_color="red", others_color="ivory")
def __init__(self, *args, **kwargs):
self.default_neuron_color = kwargs.pop("default_neuron_color",
"darksalmon")
show_axes = kwargs.pop("show_axes", True)
axes_kwargs = kwargs.pop("axes_kwargs", 1)
settings.DEFAULT_NEURITE_RADIUS = ("neurite_radius", 18)
if axes_kwargs == 1:
settings.useDepthPeeling = (
False # necessary to make the axes render properly
)
settings.useFXAA = False
# Initialise scene class
Scene.__init__(self,
add_root=False,
display_inset=False,
*args,
**kwargs)
if show_axes:
brainrender.SHOW_AXES = True
if axes_kwargs == 1:
self.plotter.axes = self._default_axes_params
else:
self.plotter.axes = axes_kwargs
def __init__(self, *args, scene_kwargs={}, **kwargs):
"""
Initialise API interaction and fetch metadata of neurons in the Allen Database.
"""
if not connected_to_internet():
raise ConnectionError(
"You will need to be connected to the internet to use the AllenMorphology class"
)
Paths.__init__(self, *args, **kwargs)
self.scene = Scene(add_root=False, display_inset=False, **scene_kwargs)
# Create a Cache for the Cell Types Cache API
self.ctc = CellTypesCache(
manifest_file=os.path.join(self.morphology_allen, 'manifest.json'))
# Get a list of cell metadata for neurons with reconstructions, download if necessary
self.neurons = pd.DataFrame(
self.ctc.get_cells(species=[CellTypesApi.MOUSE],
require_reconstruction=True))
self.n_neurons = len(self.neurons)
if not self.n_neurons:
raise ValueError(
"Something went wrong and couldn't get neurons metadata from Allen"
)
self.downloaded_neurons = self.get_downloaded_neurons()
def __init__(
self, *args, atlas=None, axes=None, random_colors=False, **kwargs
):
"""
Adds brainrender/vedo functionality to the
pyqt5 application created in bgviewer.viewer3d.ui.Window
Arguments
---------
atlas: name of a brainatlas api atlas (or any atlas class supported by brainrender)
random_colors: if True brain regions are assigned a random color
axes: by default it's None, so no axes are shown. If True is passed
Cartesian coordinates axes are shown
"""
self.scene = Scene(*args, atlas=atlas, **kwargs)
Window.__init__(self, *args, **kwargs)
self.axes = axes
# Create a new vedo plotter
self.setup_plotter()
self.random_colors = random_colors
# update plotter
self._update()
# Add inset
self.scene._get_inset()
def __init__(
self,
base_dir=None,
add_root=True,
use_cache=True,
scene_kwargs={},
**kwargs,
):
"""
Initialise the class instance to get a few useful paths and variables.
:param base_dir: str, path to base directory in which all of brainrender data are stored.
Pass only if you want to use a different one from what's default.
:param add_root: bool, if True the root mesh is added to the rendered scene
:param use_cache: if true data are loaded from a cache to speed things up.
Useful to set it to false to help debugging.
:param scene_kwargs: dict, params passed to the instance of Scene associated with this class
"""
Paths.__init__(self, base_dir=base_dir, **kwargs)
# Get MCM cache
cache_path = (Path(self.mouse_connectivity_volumetric) /
"voxel_model_manifest.json")
if not cache_path.exists():
if not connected_to_internet():
raise ValueError(
"The first time you use this class it will need to download some data, but it seems that you're not connected to the internet."
)
print(
"Downloading volumetric data. This will take several minutes but it only needs to be done once."
)
self.cache = VoxelModelCache(manifest_file=str(cache_path))
self.voxel_array = None
self.target_coords, self.source_coords = None, None
# Get projection cache paths
self.data_cache = self.mouse_connectivity_volumetric_cache
self.data_cache_projections = os.path.join(self.data_cache,
"projections")
self.data_cache_targets = os.path.join(self.data_cache, "targets")
self.data_cache_sources = os.path.join(self.data_cache, "sources")
for fold in [
self.data_cache_projections,
self.data_cache_targets,
self.data_cache_sources,
]:
if not os.path.isdir(fold):
os.mkdir(fold)
# Get structures tree
self.structure_tree = self.cache.get_structure_tree()
# Get scene
self.scene = Scene(add_root=add_root, **scene_kwargs)
# Other vars
self.use_cache = use_cache
def test_custom_video():
from brainrender.animation.video import CustomVideoMaker
# --------------------------------- Variables -------------------------------- #
N_FRAMES = 20
# Variables to specify camera position at each frame
zoom = np.linspace(1, 1.35, N_FRAMES)
frac = np.zeros_like(
zoom
) # for camera transition, interpolation value between cameras
frac[:10] = np.linspace(0, 1, 10)
frac[10:] = np.linspace(1, 0, len(frac[10:]))
# ------------------------------- Create scene ------------------------------- #
scene = Scene(display_inset=True, use_default_key_bindings=True)
filepaths, data = scene.atlas.download_streamlines_for_region("TH")
scene.add_brain_regions(["TH"], alpha=0.2)
# Create new cameras
cam1 = buildcam(sagittal_camera)
cam2 = buildcam(top_camera)
cam3 = buildcam(
dict(
position=[1862.135, -4020.792, -36292.348],
focal=[6587.835, 3849.085, 5688.164],
viewup=[0.185, -0.97, 0.161],
distance=42972.44,
clipping=[29629.503, 59872.10],
)
)
# Iniziale camera position
scene.plotter.moveCamera(cam1, cam2, frac[0])
# ------------------------------- Create frames ------------------------------ #
def frame_maker(scene=None, video=None, videomaker=None):
for step in track(
np.arange(N_FRAMES),
total=N_FRAMES,
description="Generating frames...",
):
# Move scene camera between 3 cameras
if step < 150:
scene.plotter.moveCamera(cam1, cam2, frac[step])
else:
scene.plotter.moveCamera(cam3, cam2, frac[step])
# Add frame to video
scene.render(zoom=zoom[step], interactive=False, video=True)
video.addFrame()
return video
# ---------------------------------------------------------------------------- #
# Video maker #
# ---------------------------------------------------------------------------- #
vm = CustomVideoMaker(scene, save_name="streamlines_animation")
vm.make_video(frame_maker)
def StreamlinesScene():
streamlines_files, data = streamlines_api.download_streamlines_for_region("PAG")
scene = Scene()
scene.add_streamlines(data[3], color="powderblue", show_injection_site=False, alpha=.3, radius=10)
scene.add_brain_regions(['PAG'], use_original_color=False, colors='powderblue', alpha=.9)
mos = scene.actors['regions']['PAG']
scene.edit_actors([mos], wireframe=True)
set_camera(scene)
scene.render()
def visualize_obj(obj_path, *args, color="lightcoral", **kwargs):
"""
Uses brainrender to visualize a .obj file registered to the Allen CCF
:param obj_path: str, path to a .obj file
:param color: str, color of object being rendered
"""
print("Visualizing : " + obj_path)
scene = Scene(add_root=True)
scene.add_from_file(obj_path, *args, c=color, **kwargs)
return scene
def test_scene_addition():
scene = Scene()
scene + "Examples/example_files/root.obj"
scene + scene.root
scene += scene.root
# test report
scene.list_actors()
def test_neurons():
scene = Scene()
mlapi = MouseLightAPI()
neurons_metadata = mouselight_fetch_neurons_metadata(filterby='soma', filter_regions=['MOs'])
neurons_files = mlapi.download_neurons(neurons_metadata[:2])
parser = NeuronsParser(scene=scene,
color_neurites=True, axon_color="antiquewhite",
soma_color="darkgoldenrod", dendrites_color="firebrick")
neurons, regions = parser.render_neurons(neurons_files)
scene.add_neurons(neurons_files, color_neurites=False, random_color="jet", display_axon_regions=False)
def test_streamlines():
scene = Scene()
filepaths, data = scene.atlas.download_streamlines_for_region("CA1")
scene.add_brain_regions(['CA1'], use_original_color=True, alpha=.2)
scene.add_streamlines(data,
color="darkseagreen",
show_injection_site=False)
scene.render(camera='sagittal', zoom=1, interactive=False)
scene.close()
def test_video():
s = Scene(title="BR")
s.add_brain_region("TH")
vm = VideoMaker(s, "tests", "test")
savepath = vm.make_video(duration=1, fps=15, azimuth=3)
assert savepath == "tests/test.mp4"
path = Path(savepath)
assert path.exists()
path.unlink()
def test_mouselight():
from brainrender.Utils.MouseLightAPI.mouselight_api import MouseLightAPI
from brainrender.Utils.MouseLightAPI.mouselight_info import mouselight_api_info, mouselight_fetch_neurons_metadata
# Fetch metadata for neurons with some in the secondary motor cortex
neurons_metadata = mouselight_fetch_neurons_metadata(
filterby='soma', filter_regions=['MOs'])
# Then we can download the files and save them as a .json file
ml_api = MouseLightAPI()
neurons_files = ml_api.download_neurons(
neurons_metadata[:2]
) # just saving the first couple neurons to speed things up
# Show neurons and ZI in the same scene:
scene = Scene()
scene.add_neurons(
neurons_files,
soma_color='orangered',
dendrites_color='orangered',
axon_color='darkseagreen',
neurite_radius=8
) # add_neurons takes a lot of arguments to specify how the neurons should look
# make sure to check the source code to see all available optionsq
scene.add_brain_regions(['MOs'], alpha=0.15)
scene.render(camera='coronal')
def _make_root(self, rootpath):
"""
Creates a root mesh by merging the mesh corresponding to each neuron,
then saves it as an obj file at rootpath
"""
raise NotImplementedError(
"Create root method not supported yet, sorry")
print(f"Creating root mesh for atlas {self.atlas_name}")
temp_scene = Scene(
atlas=Celegans,
add_root=False,
display_inset=False,
atlas_kwargs=dict(data_folder=self.data_folder),
)
temp_scene.add_neurons(self.neurons_names)
temp_scene.render(interactive=False)
temp_scene.close()
root = merge(*temp_scene.actors["neurons"]).clean().cap()
# root = mesh2Volume(root, spacing=(0.02, 0.02, 0.02)).isosurface()
points = Points(root.points()).smoothMLS2D(f=0.8).clean(tol=0.005)
root = recoSurface(points, dims=100, radius=0.2)
# Save
write(root, rootpath)
del temp_scene
return root
def test_neurons():
scene = Scene()
mlapi = MouseLightAPI()
# Fetch metadata for neurons with some in the secondary motor cortex
neurons_metadata = mlapi.fetch_neurons_metadata(filterby='soma', filter_regions=['MOs'])
# Then we can download the files and save them as a .json file
neurons = mlapi.download_neurons(neurons_metadata[:5])
scene = Scene(title='One color')
scene.add_neurons(neurons, color='salmon', display_axon=True, neurite_radius=6)
scene.render(interactive=False)
scene.close()
def load_regions_into_brainrender(list_of_regions, alpha=0.8, shading="flat"):
"""
Loads a list of .obj files into brainrender
:param list_of_regions: List of .obj files to be loaded
:param alpha: Object transparency
:param shading: Object shading type ("flat", "giroud" or "phong").
Defaults to "phong"
"""
scene = Scene()
for obj_file in list_of_regions:
load_obj_into_brainrender(scene,
obj_file,
alpha=alpha,
shading=shading)
scene.render()
def BrainRegionsScene():
scene = Scene()
scene.add_brain_regions(['TH', 'VP'], use_original_color=True, alpha=1)
act = scene.actors['regions']['TH']
scene.edit_actors([act], wireframe=True)
scene.render()
def test_video_custom():
def custom(scene, *args, **kwargs):
return
s = Scene(title="BR")
s.add_brain_region("TH")
vm = VideoMaker(s, "tests", "test", make_frame_func=custom)
savepath = vm.make_video(duration=1, fps=15, azimuth=3)
assert savepath == "tests/test.mp4"
path = Path(savepath)
assert path.exists()
path.unlink()
def ConnectivityScene():
scene = Scene()
p0 = scene.get_region_CenterOfMass("ZI")
# Then we se these coordinates to get tractography data, note: any set of X,Y,Z coordinates would do.
tract = aba.get_projection_tracts_to_target(p0=p0)
scene.add_tractography(tract, display_injection_structure=False, color_by="region",
display_injection_volume=True, others_alpha=.25)
scene.add_brain_regions(['ZI'], colors="ivory", alpha=1)
set_camera(scene)
scene.render()
def test_streamlines():
from brainrender.Utils.parsers.streamlines import StreamlinesAPI
# Download streamlines data for injections in the CA1 field of the hippocampus
streamlines_api = StreamlinesAPI()
filepaths, data = streamlines_api.download_streamlines_for_region("CA1")
# Start by creating a scene
scene = Scene()
scene.add_brain_regions(['CA1'], use_original_color=True, alpha=.2)
# you can pass either the filepaths or the data
scene.add_streamlines(data, color="darkseagreen", show_injection_site=False)
scene.render(interactive=False, camera='sagittal', zoom=1)
scene.close()
def test_regions():
scene = Scene(camera=coronal_camera)
regions = ["MOs", "VISp", "ZI"]
scene.add_brain_regions(regions, colors="green")
ca1 = scene.add_brain_regions("CA1", add_labels=True)
ca1.alpha(0.2)
scene.close()
def NeuronsScene2():
scene = Scene()
neurons_metadata = mouselight_fetch_neurons_metadata(filterby='soma', filter_regions=['MOp5'])
neurons_files = mlapi.download_neurons(neurons_metadata[2:6])
scene.add_neurons(neurons_files, soma_color='deepskyblue', force_to_hemisphere="right")
streamlines_files, data = streamlines_api.download_streamlines_for_region("MOp")
scene.add_streamlines(data[:1], color="palegreen", show_injection_site=False, alpha=.2, radius=10)
set_camera(scene)
scene.render()
def test_video():
from brainrender.animation.video import BasicVideoMaker as VideoMaker
scene = Scene()
# Create an instance of VideoMaker with our scene
vm = VideoMaker(scene, niters=10)
# Make a video!
vm.make_video(elevation=1, roll=5) # specify how the scene rotates at each frame
def NeuronsScene(show_regions = False):
scene = Scene()
fl = 'Examples/example_files/one_neuron.json'
scene.add_neurons(fl, soma_color='darkseagreen', force_to_hemisphere="right",)
if show_regions:
scene.add_brain_regions(['ZI', 'PAG', 'MRN', 'NPC', "VTA", "STN", "PPT", "SCm", "HY"],
use_original_color=True, alpha=.5)
set_camera(scene)
scene.render()
def test_animation():
# Create a brainrender scene
scene = Scene(title="brain regions", inset=False)
# Add brain regions
scene.add_brain_region("TH")
anim = Animation(scene, "tests", "test")
anim.add_keyframe(0, camera="top", zoom=1.3)
anim.add_keyframe(1, camera="sagittal", zoom=2.1)
anim.add_keyframe(2, camera="frontal", zoom=3)
anim.add_keyframe(3, camera="frontal", zoom=2)
anim.add_keyframe(3, camera="frontal", zoom=2) # overwrite
anim.add_keyframe(30, camera="frontal", zoom=2) # too many
savepath = anim.make_video(duration=3, fps=10)
assert savepath == "tests/test.mp4"
path = Path(savepath)
assert path.exists()
path.unlink()
def test_video():
from brainrender.Utils.videomaker import VideoMaker
scene = Scene()
# Create an instance of VideoMaker with our scene
vm = VideoMaker(scene, savefile="Output/Videos/video.mp4", niters=10)
# Make a video!
vm.make_video(elevation=1,
roll=5) # specify how the scene rotates at each frame
def test_camera():
# Create a scene
scene = Scene(camera='top') # specify that you want a view from the top
# render
scene.render(interactive=False, )
scene.close()
# Now render but with a different view
scene.render(interactive=False, camera='sagittal', zoom=1)
scene.close()
# Now render but with specific camera parameters
bespoke_camera = dict(
position = [801.843, -1339.564, 8120.729] ,
focal = [9207.34, 2416.64, 5689.725],
viewup = [0.36, -0.917, -0.171],
distance = 9522.144,
clipping = [5892.778, 14113.736],
)
def test_fish_neurons():
api = MpinMorphologyAPI()
# api.download_dataset()
neurons_ids = api.get_neurons_by_structure(837)[:5]
neurons = api.load_neurons(neurons_ids)
neurons = [
neuron.create_mesh(soma_radius=1, neurite_radius=1)[1]
for neuron in neurons
]
scene = Scene(atlas="mpin_zfish_1um", add_root=True, camera="sagittal2")
scene.add_neurons(neurons)
scene.render(interactive=False)
scene.close()
def test_tractography():
from brainrender.atlases.aba import ABA
# Create a scene
scene = Scene()
# Get the center of mass of the region of interest
p0 = scene.get_region_CenterOfMass("ZI")
# Get projections to that point
analyzer = ABA()
tract = analyzer.get_projection_tracts_to_target(p0=p0)
# Add the brain regions and the projections to it
scene.add_brain_regions(['ZI'], alpha=.4, use_original_color=True)
scene.add_tractography(tract,
display_injection_structure=False,
color_by="region")
scene.render()
def ElectrodesArrayScene():
scene = Scene(add_root=False, camera='sagittal')
z_offset = -1500
scene.add_brain_regions(['VAL'], use_original_color=True, alpha=.5)
scene.add_brain_regions(['TH'],
use_original_color=True,
alpha=.5,
wireframe=True)
# scene.add_optic_cannula('VAL')
# for x_offset in [-200, -500, -800, -1100]:
# scene.add_optic_cannula('VAL', z_offset=z_offset, x_offset=x_offset, alpha=1,
# radius=50, y_offset=-500, color='blackboard')
scene.render()
