def get_structure_tree(self, file_name=None, structure_graph_id=1):
"""
Read the list of adult mouse structures and return an StructureTree
instance.
Parameters
----------
file_name: string
File name to save/read the structures table. If file_name is None,
the file_name will be pulled out of the manifest. If caching
is disabled, no file will be saved. Default is None.
structure_graph_id: int
Build a tree using structure only from the identified structure graph.
"""
file_name = self.get_cache_path(file_name, self.STRUCTURE_TREE_KEY)
return OntologiesApi(self.api.api_url).get_structures_with_sets(
strategy='lazy',
path=file_name,
pre=StructureTree.clean_structures,
post=lambda x: StructureTree(StructureTree.clean_structures(x)),
structure_graph_ids=structure_graph_id,
**Cache.cache_json())
def get_structures(self, file_name=None):
"""
Read the list of adult mouse structures and return a Pandas DataFrame.
Parameters
----------
file_name: string
File name to save/read the structures table. If file_name is None,
the file_name will be pulled out of the manifest. If caching
is disabled, no file will be saved. Default is None.
"""
file_name = self.get_cache_path(file_name, self.STRUCTURES_KEY)
if os.path.exists(file_name):
structures = pd.DataFrame.from_csv(file_name)
else:
structures = OntologiesApi().get_structures(1)
structures = pd.DataFrame(structures)
if self.cache:
Manifest.safe_mkdir(os.path.dirname(file_name))
structures.to_csv(file_name)
structures.set_index(['id'], inplace=True, drop=False)
return structures
def oapi():
oa = OntologiesApi()
oa.get_structures = mock.MagicMock(return_value=[{'id': 1, 'structure_id_path': '1'}])
oa.get_structure_set_map = mock.MagicMock(return_value={1: [2, 3]})
return oa
def allen_volume_from_structures(structures=selection_dorsal_cortex,
resolution=10,
version='annotation/ccf_2017'):
'''
Gets specific regions from an annotation volume from the allen atlas
'''
from allensdk.api.queries.mouse_connectivity_api import MouseConnectivityApi
from allensdk.api.queries.ontologies_api import OntologiesApi
from allensdk.core.structure_tree import StructureTree
from allensdk.core.reference_space import ReferenceSpace
# the annotation download writes a file, so we will need somwhere to put it
# the annotation download writes a file, so we will need somwhere to put it
annotation, meta = allen_get_raw_annotation(annotation_dir,
version=version,
resolution=10)
oapi = OntologiesApi()
structure_graph = oapi.get_structures_with_sets(
[1]) # 1 is the id of the adult mouse structure graph
# This removes some unused fields returned by the query
structure_graph = StructureTree.clean_structures(structure_graph)
tree = StructureTree(structure_graph)
rsp = ReferenceSpace(tree, annotation, [resolution] * 3)
areas = rsp.structure_tree.get_structures_by_acronym(structures)
ids = [st['id'] for st in areas]
mask_volume = np.zeros_like(annotation, dtype='int16')
for i, sid in tqdm(enumerate(ids)):
masks = rsp.make_structure_mask([sid])
mask_volume[masks == 1] = i + 1
areas[i]['mask_volume_id'] = i + 1
return mask_volume, areas
def __init__(self):
# get mouse connectivity cache and structure tree
self.mcc = MouseConnectivityCache(manifest_file=os.path.join(
self.mouse_connectivity_cache, "manifest.json"))
self.structure_tree = self.mcc.get_structure_tree()
# get ontologies API and brain structures sets
self.oapi = OntologiesApi()
# get reference space
self.space = ReferenceSpaceApi()
self.spacecache = ReferenceSpaceCache(
manifest=os.path.join(
self.annotated_volume_fld, "manifest.json"
), # downloaded files are stored relative to here
resolution=int(self.resolution[0]),
reference_space_key=
"annotation/ccf_2017", # use the latest version of the CCF
)
self.annotated_volume, _ = self.spacecache.get_annotation_volume()
# mouse connectivity API [used for tractography]
self.mca = MouseConnectivityApi()
# Get tree search api
self.tree_search = TreeSearchApi()
def Ref():
oapi = OntologiesApi()
structure_graph = oapi.get_structures_with_sets([1])
structure_graph = StructureTree.clean_structures(structure_graph)
tree = StructureTree(structure_graph)
# "need to download annotation the first time"
# annotation_dir = 'annotation'
# Manifest.safe_mkdir(annotation_dir)
# annotation_path = os.path.join(annotation_dir, 'annotation.nrrd')
annotation_path = 'annotation_2017_25.nrrd'
# mcapi = MouseConnectivityApi()
# mcapi.download_annotation_volume('annotation/ccf_2016', 25, annotation_path)
annotation, meta = nrrd.read(annotation_path)
rsp = ReferenceSpace(tree, annotation, [25, 25, 25])
import pandas as pd
df = pd.read_csv('ontology_170731.csv')
idList = df['id']
acronymList = df['acronym']
nameList = df['name']
voxel_count = [rsp.total_voxel_map[int(stid)] for stid in df['id']]
df = pd.DataFrame(np.column_stack(
[idList, acronymList, nameList, voxel_count]),
columns=['ID', 'Acronym', 'Name', 'Total Voxel'])
df.to_csv('s2_{}.csv'.format(time.strftime('%y%m%d')))
def getFullStructureTree():
oapi = OntologiesApi()
structure_graph = oapi.get_structures_with_sets([1]) # 1 is the id of the adult mouse structure graph
# structure_graph = oapi.get_structures(structure_graph_ids=1) # (Alternative method)
# This removes some unused fields returned by the query
structure_graph = StructureTree.clean_structures(structure_graph)
tree = StructureTree(structure_graph)
return tree
def getMsTree():
oapi = OntologiesApi()
# The 1 refers to the adult mouse brain atlas
structure_graph = oapi.get_structures_with_sets([1])
# clean_structures() removes unused fields
structure_graph = StructureTree.clean_structures(structure_graph)
# a class with methods for aceessing and using ontologies data
tree = StructureTree(structure_graph)
return tree
def __init__(self,
projection_metric="projection_energy",
base_dir=None,
**kwargs):
"""
Set up file paths and Allen SDKs
:param base_dir: path to directory to use for saving data (default value None)
:param path_fiprojection_metricle: - str, metric to quantify the strength of projections from the Allen Connectome. (default value 'projection_energy')
:param kwargs: can be used to pass path to individual data folders. See brainrender/Utils/paths_manager.py
"""
Paths.__init__(self, base_dir=base_dir, **kwargs)
self.projection_metric = projection_metric
# get mouse connectivity cache and structure tree
self.mcc = MouseConnectivityCache(manifest_file=os.path.join(
self.mouse_connectivity_cache, "manifest.json"))
self.structure_tree = self.mcc.get_structure_tree()
# get ontologies API and brain structures sets
self.oapi = OntologiesApi()
self.get_structures_sets()
# get reference space
self.space = ReferenceSpaceApi()
self.spacecache = ReferenceSpaceCache(
manifest=os.path.join(
self.annotated_volume, "manifest.json"
), # downloaded files are stored relative to here
resolution=self.resolution,
reference_space_key=
"annotation/ccf_2017" # use the latest version of the CCF
)
self.annotated_volume, _ = self.spacecache.get_annotation_volume()
# mouse connectivity API [used for tractography]
self.mca = MouseConnectivityApi()
# Get tree search api
self.tree_search = TreeSearchApi()
# Get some metadata about experiments
self.all_experiments = self.mcc.get_experiments(dataframe=True)
self.strains = sorted(
[x for x in set(self.all_experiments.strain) if x is not None])
self.transgenic_lines = sorted(
set([
x for x in set(self.all_experiments.transgenic_line)
if x is not None
]))
def __init__(self, graph: str = "adult") -> None:
self._onto = OntologiesApi()
if graph == "adult":
self._struct_dicts_list = self._onto.get_structures(
structure_graph_ids=1, num_rows='all')
elif graph == "development":
self._struct_dicts_list = self._onto.get_structures(
structure_graph_ids=17, num_rows='all')
self._structures = {
i["id"]: AllenBrainStructure(i, self)
for i in self._struct_dicts_list
}
self._link()
def writeStructDFs(df, structName_list, filename, IDheader='id', exclude=None):
oapi = OntologiesApi()
# The 1 refers to the adult mouse brain atlas
structure_graph = oapi.get_structures_with_sets([1])
# clean_structures() removes unused fields
structure_graph = StructureTree.clean_structures(structure_graph)
# a class with methods for aceessing and using ontologies data
tree = StructureTree(structure_graph)
for structName in structName_list:
towrite = getStructDF(df,
structName,
tree,
IDheader=IDheader,
exclude=exclude)
writename = structName + filename
towrite.to_csv(writename, sep='\t')
def __init__(self, projection_metric="projection_energy", paths_file=None):
""" path_file {[str]} -- [Path to a YAML file specifying paths to data folders, to replace default paths] (default: {None}) """
Paths.__init__(self, paths_file=paths_file)
self.projection_metric = projection_metric
# get mouse connectivity cache and structure tree
self.mcc = MouseConnectivityCache(manifest_file=os.path.join(
self.mouse_connectivity_cache, "manifest.json"))
self.structure_tree = self.mcc.get_structure_tree()
# get ontologies API and brain structures sets
self.oapi = OntologiesApi()
self.get_structures_sets()
# get reference space
self.space = ReferenceSpaceApi()
self.spacecache = ReferenceSpaceCache(
manifest=os.path.join(
"Data/ABA", "manifest.json"
), # downloaded files are stored relative to here
resolution=self.resolution,
reference_space_key=
"annotation/ccf_2017" # use the latest version of the CCF
)
self.annotated_volume, _ = self.spacecache.get_annotation_volume()
# mouse connectivity API [used for tractography]
self.mca = MouseConnectivityApi()
# Get tree search api
self.tree_search = TreeSearchApi()
# Get some metadata about experiments
self.all_experiments = self.mcc.get_experiments(dataframe=True)
self.strains = sorted(
[x for x in set(self.all_experiments.strain) if x is not None])
self.transgenic_lines = sorted(
set([
x for x in set(self.all_experiments.transgenic_line)
if x is not None
]))
def __init__(self, base_dir=None, **kwargs):
"""
Set up file paths and Allen SDKs
:param base_dir: path to directory to use for saving data (default value None)
:param kwargs: can be used to pass path to individual data folders. See brainrender/Utils/paths_manager.py
"""
Atlas.__init__(self, base_dir=base_dir, **kwargs)
self.meshes_folder = self.mouse_meshes # where the .obj mesh for each region is saved
# get mouse connectivity cache and structure tree
self.mcc = MouseConnectivityCache(manifest_file=os.path.join(self.mouse_connectivity_cache, "manifest.json"))
self.structure_tree = self.mcc.get_structure_tree()
# get ontologies API and brain structures sets
self.oapi = OntologiesApi()
self.get_structures_sets()
# get reference space
self.space = ReferenceSpaceApi()
self.spacecache = ReferenceSpaceCache(
manifest=os.path.join(self.annotated_volume_fld, "manifest.json"), # downloaded files are stored relative to here
resolution=self.resolution,
reference_space_key="annotation/ccf_2017" # use the latest version of the CCF
)
self.annotated_volume, _ = self.spacecache.get_annotation_volume()
# mouse connectivity API [used for tractography]
self.mca = MouseConnectivityApi()
# Get tree search api
self.tree_search = TreeSearchApi()
# Store all regions metadata [If there's internet connection]
if self.other_sets is not None:
self.regions = self.other_sets["Structures whose surfaces are represented by a precomputed mesh"].sort_values('acronym')
self.region_acronyms = list(self.other_sets["Structures whose surfaces are represented by a precomputed mesh"].sort_values(
'acronym').acronym.values)
def __init__(self):
SvgApi.__init__(
self
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/svg_api.py
ImageDownloadApi.__init__(
self
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/image_download_api.py
self.annsetsapi = AnnotatedSectionDataSetsApi(
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/annotated_section_data_sets_api.py
self.oapi = OntologiesApi(
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/ontologies_api.py
# Get metadata about atlases
self.atlases = pd.DataFrame(self.oapi.get_atlases_table())
self.atlases_names = sorted(list(self.atlases['name'].values))
self.mouse_coronal_atlas_id = int(self.atlases.loc[
self.atlases['name'] == "Mouse, P56, Coronal"].id.values[0])
self.mouse_sagittal_atlas_id = int(self.atlases.loc[
self.atlases['name'] == "Mouse, P56, Sagittal"].id.values[0])
self.mouse_3D_atlas_id = int(self.atlases.loc[
self.atlases['name'] == "Mouse, Adult, 3D Coronal"].id.values[0])
# Get metadata about products
if connected_to_internet():
self.products = pd.DataFrame(
send_query(
"http://api.brain-map.org/api/v2/data/query.json?criteria=model::Product"
))
self.mouse_brain_reference_product_id = 12
self.mouse_brain_ish_data_product_id = 1
self.products_names = sorted(list(self.products["name"].values))
self.mouse_products_names = sorted(
list(self.products.loc[self.products.species == "Mouse"]
["name"].values))
else:
raise ConnectionError(
"It seems that you are not connected to the internet, you won't be able to download stuff."
)
def __init__(self):
SvgApi.__init__(
self
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/svg_api.py
ImageDownloadApi.__init__(
self
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/image_download_api.py
self.annsetsapi = (
AnnotatedSectionDataSetsApi()
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/annotated_section_data_sets_api.py
self.oapi = (
OntologiesApi()
) # https://github.com/AllenInstitute/AllenSDK/blob/master/allensdk/api/queries/ontologies_api.py
# Get metadata about atlases
self.atlases = pd.DataFrame(self.oapi.get_atlases_table())
self.atlases_names = sorted(list(self.atlases["name"].values))
self.mouse_coronal_atlas_id = int(self.atlases.loc[
self.atlases["name"] == self.mouse_coronal].id.values[0])
self.mouse_sagittal_atlas_id = int(self.atlases.loc[
self.atlases["name"] == self.mouse_sagittal].id.values[0])
self.mouse_3D_atlas_id = int(self.atlases.loc[
self.atlases["name"] == self.mouse3d].id.values[0])
# Get metadata about products
self.products = pd.DataFrame(
send_query(
"http://api.brain-map.org/api/v2/data/query.json?criteria=model::Product"
))
self.mouse_brain_reference_product_id = 12
self.mouse_brain_ish_data_product_id = 1
self.products_names = sorted(list(self.products["name"].values))
self.mouse_products_names = sorted(
list(self.products.loc[self.products.species == "Mouse"]
["name"].values))
# open up a list of all of the experiments
all_experiments = mcc.get_experiments(dataframe=True)
print("{} total experiments".format(len(all_experiments)))
# take a look at what we know about an experiment with a primary motor injection
print(all_experiments.loc[122642490])
# grab the StructureTree instance
structure_tree = mcc.get_structure_tree()
print(structure_tree)
from allensdk.api.queries.ontologies_api import OntologiesApi
oapi = OntologiesApi()
# get the ids of all the structure sets in the tree
structure_set_ids = structure_tree.get_structure_sets()
# query the API for information on those structure sets
#print(oapi.get_structure_sets(structure_set_ids))
#
#structures = structure_tree.get_structures_by_set_id([167587189])
#print(structures)
# Projection grid data volume
experiment_id = 181599674
def test_notebook(fn_temp_dir):
# coding: utf-8
# # Reference Space
#
# This notebook contains example code demonstrating the use of the StructureTree and ReferenceSpace classes. These classes provide methods for interacting with the 3d spaces to which Allen Institute data and atlases are registered.
#
# Unlike the AllenSDK cache classes, StructureTree and ReferenceSpace operate entirely in memory. We recommend using json files to store text and nrrd files to store volumetric images.
#
# The MouseConnectivityCache class has methods for downloading, storing, and constructing StructureTrees and ReferenceSpaces. Please see [here](https://alleninstitute.github.io/AllenSDK/_static/examples/nb/mouse_connectivity.html) for examples.
# ## Constructing a StructureTree
#
# A StructureTree object is a wrapper around a structure graph - a list of dictionaries documenting brain structures and their containment relationships. To build a structure tree, you will first need to obtain a structure graph.
#
# For a list of atlases and corresponding structure graph ids, see [here](http://help.brain-map.org/display/api/Atlas+Drawings+and+Ontologies).
# In[1]:
from allensdk.api.queries.ontologies_api import OntologiesApi
from allensdk.core.structure_tree import StructureTree
oapi = OntologiesApi()
structure_graph = oapi.get_structures_with_sets(
[1]) # 1 is the id of the adult mouse structure graph
# This removes some unused fields returned by the query
structure_graph = StructureTree.clean_structures(structure_graph)
tree = StructureTree(structure_graph)
# In[2]:
# now let's take a look at a structure
tree.get_structures_by_name(['Dorsal auditory area'])
# The fields are:
# * acronym: a shortened name for the structure
# * rgb_triplet: each structure is assigned a consistent color for visualizations
# * graph_id: the structure graph to which this structure belongs
# * graph_order: each structure is assigned a consistent position in the flattened graph
# * id: a unique integer identifier
# * name: the full name of the structure
# * structure_id_path: traces a path from the root node of the tree to this structure
# * structure_set_ids: the structure belongs to these predefined groups
# ## Using a StructureTree
# In[3]:
# get a structure's parent
tree.parent([1011])
# In[4]:
# get a dictionary mapping structure ids to names
name_map = tree.get_name_map()
name_map[247]
# In[5]:
# ask whether one structure is contained within another
strida = 385
stridb = 247
is_desc = '' if tree.structure_descends_from(385, 247) else ' not'
print('{0} is{1} in {2}'.format(name_map[strida], is_desc,
name_map[stridb]))
# In[6]:
# build a custom map that looks up acronyms by ids
# the syntax here is just a pair of node-wise functions.
# The first one returns keys while the second one returns values
acronym_map = tree.value_map(lambda x: x['id'], lambda y: y['acronym'])
print(acronym_map[385])
# ## Downloading an annotation volume
#
# This code snippet will download and store a nrrd file containing the Allen Common Coordinate Framework annotation. We have requested an annotation with 25-micron isometric spacing. The orientation of this space is:
# * Anterior -> Posterior
# * Superior -> Inferior
# * Left -> Right
# This is the no-frills way to download an annotation volume. See the <a href='_static/examples/nb/mouse_connectivity.html#Manipulating-Grid-Data'>mouse connectivity</a> examples if you want to properly cache the downloaded data.
# In[7]:
import os
import nrrd
from allensdk.api.queries.mouse_connectivity_api import MouseConnectivityApi
from allensdk.config.manifest import Manifest
# the annotation download writes a file, so we will need somwhere to put it
annotation_dir = 'annotation'
Manifest.safe_mkdir(annotation_dir)
annotation_path = os.path.join(annotation_dir, 'annotation.nrrd')
mcapi = MouseConnectivityApi()
mcapi.download_annotation_volume('annotation/ccf_2016', 25,
annotation_path)
annotation, meta = nrrd.read(annotation_path)
# ## Constructing a ReferenceSpace
# In[8]:
from allensdk.core.reference_space import ReferenceSpace
# build a reference space from a StructureTree and annotation volume, the third argument is
# the resolution of the space in microns
rsp = ReferenceSpace(tree, annotation, [25, 25, 25])
# ## Using a ReferenceSpace
# #### making structure masks
#
# The simplest use of a Reference space is to build binary indicator masks for structures or groups of structures.
# In[9]:
# A complete mask for one structure
whole_cortex_mask = rsp.make_structure_mask([315])
# view in coronal section
# What if you want a mask for a whole collection of ontologically disparate structures? Just pass more structure ids to make_structure_masks:
# In[10]:
# This gets all of the structures targeted by the Allen Brain Observatory project
brain_observatory_structures = rsp.structure_tree.get_structures_by_set_id(
[514166994])
brain_observatory_ids = [st['id'] for st in brain_observatory_structures]
brain_observatory_mask = rsp.make_structure_mask(brain_observatory_ids)
# view in horizontal section
# You can also make and store a number of structure_masks at once:
# In[11]:
import functools
# Define a wrapper function that will control the mask generation.
# This one checks for a nrrd file in the specified base directory
# and builds/writes the mask only if one does not exist
mask_writer = functools.partial(ReferenceSpace.check_and_write,
annotation_dir)
# many_structure_masks is a generator - nothing has actrually been run yet
mask_generator = rsp.many_structure_masks([385, 1097], mask_writer)
# consume the resulting iterator to make and write the masks
for structure_id in mask_generator:
print('made mask for structure {0}.'.format(structure_id))
os.listdir(annotation_dir)
# #### Removing unassigned structures
# A structure graph may contain structures that are not used in a particular reference space. Having these around can complicate use of the reference space, so we generally want to remove them.
#
# We'll try this using "Somatosensory areas, layer 6a" as a test case. In the 2016 ccf space, this structure is unused in favor of finer distinctions (e.g. "Primary somatosensory area, barrel field, layer 6a").
# In[12]:
# Double-check the voxel counts
no_voxel_id = rsp.structure_tree.get_structures_by_name(
['Somatosensory areas, layer 6a'])[0]['id']
print('voxel count for structure {0}: {1}'.format(
no_voxel_id, rsp.total_voxel_map[no_voxel_id]))
# remove unassigned structures from the ReferenceSpace's StructureTree
rsp.remove_unassigned()
# check the structure tree
no_voxel_id in rsp.structure_tree.node_ids()
# #### View a slice from the annotation
# In[13]:
import numpy as np
# #### Downsample the space
#
# If you want an annotation at a resolution we don't provide, you can make one with the downsample method.
# In[14]:
import warnings
target_resolution = [75, 75, 75]
# in some versions of scipy, scipy.ndimage.zoom raises a helpful but distracting
# warning about the method used to truncate integers.
warnings.simplefilter('ignore')
sf_rsp = rsp.downsample(target_resolution)
# re-enable warnings
warnings.simplefilter('default')
print(rsp.annotation.shape)
print(sf_rsp.annotation.shape)
def ontologies():
return OntologiesApi()
def test_notebook(fn_temp_dir):
# coding: utf-8
# ## Mouse Connectivity
#
# This notebook demonstrates how to access and manipulate data in the Allen Mouse Brain Connectivity Atlas. The `MouseConnectivityCache` AllenSDK class provides methods for downloading metadata about experiments, including their viral injection site and the mouse's transgenic line. You can request information either as a Pandas DataFrame or a simple list of dictionaries.
#
# An important feature of the `MouseConnectivityCache` is how it stores and retrieves data for you. By default, it will create (or read) a manifest file that keeps track of where various connectivity atlas data are stored. If you request something that has not already been downloaded, it will download it and store it in a well known location.
#
# Download this notebook in .ipynb format <a href='mouse_connectivity.ipynb'>here</a>.
# In[1]:
from allensdk.core.mouse_connectivity_cache import MouseConnectivityCache
# The manifest file is a simple JSON file that keeps track of all of
# the data that has already been downloaded onto the hard drives.
# If you supply a relative path, it is assumed to be relative to your
# current working directory.
mcc = MouseConnectivityCache(manifest_file='connectivity/mouse_connectivity_manifest.json')
# open up a list of all of the experiments
all_experiments = mcc.get_experiments(dataframe=True)
print("%d total experiments" % len(all_experiments))
# take a look at what we know about an experiment with a primary motor injection
all_experiments.loc[122642490]
# `MouseConnectivityCache` has a method for retrieving the adult mouse structure tree as an `StructureTree` class instance. This is a wrapper around a list of dictionaries, where each dictionary describes a structure. It is principally useful for looking up structures by their properties.
# In[2]:
# pandas for nice tables
import pandas as pd
# grab the StructureTree instance
structure_tree = mcc.get_structure_tree()
# get info on some structures
structures = structure_tree.get_structures_by_name(['Primary visual area', 'Hypothalamus'])
pd.DataFrame(structures)
# As a convenience, structures are grouped in to named collections called "structure sets". These sets can be used to quickly gather a useful subset of structures from the tree. The criteria used to define structure sets are eclectic; a structure set might list:
#
# * structures that were used in a particular project.
# * structures that coarsely partition the brain.
# * structures that bear functional similarity.
#
# or something else entirely. To view all of the available structure sets along with their descriptions, follow this [link](http://api.brain-map.org/api/v2/data/StructureSet/query.json). To see only structure sets relevant to the adult mouse brain, use the StructureTree:
# In[3]:
from allensdk.api.queries.ontologies_api import OntologiesApi
oapi = OntologiesApi()
# get the ids of all the structure sets in the tree
structure_set_ids = structure_tree.get_structure_sets()
# query the API for information on those structure sets
pd.DataFrame(oapi.get_structure_sets(structure_set_ids))
# On the connectivity atlas web site, you'll see that we show most of our data at a fairly coarse structure level. We did this by creating a structure set of ~300 structures, which we call the "summary structures". We can use the structure tree to get all of the structures in this set:
# In[4]:
# From the above table, "Mouse Connectivity - Summary" has id 167587189
summary_structures = structure_tree.get_structures_by_set_id([167587189])
pd.DataFrame(summary_structures)
# This is how you can filter experiments by transgenic line:
# In[5]:
# fetch the experiments that have injections in the isocortex of cre-positive mice
isocortex = structure_tree.get_structures_by_name(['Isocortex'])[0]
cre_cortical_experiments = mcc.get_experiments(cre=True,
injection_structure_ids=[isocortex['id']])
print("%d cre cortical experiments" % len(cre_cortical_experiments))
# same as before, but restrict the cre line
rbp4_cortical_experiments = mcc.get_experiments(cre=[ 'Rbp4-Cre_KL100' ],
injection_structure_ids=[isocortex['id']])
print("%d Rbp4 cortical experiments" % len(rbp4_cortical_experiments))
# ## Structure Signal Unionization
#
# The ProjectionStructureUnionizes API data tells you how much signal there was in a given structure and experiment. It contains the density of projecting signal, volume of projecting signal, and other information. `MouseConnectivityCache` provides methods for querying and storing this data.
# In[6]:
# find wild-type injections into primary visual area
visp = structure_tree.get_structures_by_acronym(['VISp'])[0]
visp_experiments = mcc.get_experiments(cre=False,
injection_structure_ids=[visp['id']])
print("%d VISp experiments" % len(visp_experiments))
structure_unionizes = mcc.get_structure_unionizes([ e['id'] for e in visp_experiments ],
is_injection=False,
structure_ids=[isocortex['id']],
include_descendants=True)
print("%d VISp non-injection, cortical structure unionizes" % len(structure_unionizes))
# In[7]:
structure_unionizes.head()
# This is a rather large table, even for a relatively small number of experiments. You can filter it down to a smaller list of structures like this.
# In[8]:
dense_unionizes = structure_unionizes[ structure_unionizes.projection_density > .5 ]
large_unionizes = dense_unionizes[ dense_unionizes.volume > .5 ]
large_structures = pd.DataFrame(structure_tree.nodes(large_unionizes.structure_id))
print("%d large, dense, cortical, non-injection unionizes, %d structures" % ( len(large_unionizes), len(large_structures) ))
print(large_structures.name)
large_unionizes
# ## Generating a Projection Matrix
# The `MouseConnectivityCache` class provides a helper method for converting ProjectionStructureUnionize records for a set of experiments and structures into a matrix. This code snippet demonstrates how to make a matrix of projection density values in auditory sub-structures for cre-negative VISp experiments.
# In[9]:
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
visp_experiment_ids = [ e['id'] for e in visp_experiments ]
ctx_children = structure_tree.child_ids( [isocortex['id']] )[0]
pm = mcc.get_projection_matrix(experiment_ids = visp_experiment_ids,
projection_structure_ids = ctx_children,
hemisphere_ids= [2], # right hemisphere, ipsilateral
parameter = 'projection_density')
row_labels = pm['rows'] # these are just experiment ids
column_labels = [ c['label'] for c in pm['columns'] ]
matrix = pm['matrix']
fig, ax = plt.subplots(figsize=(15,15))
heatmap = ax.pcolor(matrix, cmap=plt.cm.afmhot)
# put the major ticks at the middle of each cell
ax.set_xticks(np.arange(matrix.shape[1])+0.5, minor=False)
ax.set_yticks(np.arange(matrix.shape[0])+0.5, minor=False)
ax.set_xlim([0, matrix.shape[1]])
ax.set_ylim([0, matrix.shape[0]])
# want a more natural, table-like display
ax.invert_yaxis()
ax.xaxis.tick_top()
ax.set_xticklabels(column_labels, minor=False)
ax.set_yticklabels(row_labels, minor=False)
# ## Manipulating Grid Data
#
# The `MouseConnectivityCache` class also helps you download and open every experiment's projection grid data volume. By default it will download 25um volumes, but you could also download data at other resolutions if you prefer (10um, 50um, 100um).
#
# This demonstrates how you can load the projection density for a particular experiment. It also shows how to download the template volume to which all grid data is registered. Voxels in that template have been structurally annotated by neuroanatomists and the resulting labels stored in a separate annotation volume image.
# In[10]:
# we'll take this experiment - an injection into the primary somatosensory - as an example
experiment_id = 181599674
# In[11]:
# projection density: number of projecting pixels / voxel volume
pd, pd_info = mcc.get_projection_density(experiment_id)
# injection density: number of projecting pixels in injection site / voxel volume
ind, ind_info = mcc.get_injection_density(experiment_id)
# injection fraction: number of pixels in injection site / voxel volume
inf, inf_info = mcc.get_injection_fraction(experiment_id)
# data mask:
# binary mask indicating which voxels contain valid data
dm, dm_info = mcc.get_data_mask(experiment_id)
template, template_info = mcc.get_template_volume()
annot, annot_info = mcc.get_annotation_volume()
# in addition to the annotation volume, you can get binary masks for individual structures
# in this case, we'll get one for the isocortex
cortex_mask, cm_info = mcc.get_structure_mask(315)
print(pd_info)
print(pd.shape, template.shape, annot.shape)
# Once you have these loaded, you can use matplotlib see what they look like.
# In[12]:
# compute the maximum intensity projection (along the anterior-posterior axis) of the projection data
pd_mip = pd.max(axis=0)
ind_mip = ind.max(axis=0)
inf_mip = inf.max(axis=0)
# show that slice of all volumes side-by-side
f, pr_axes = plt.subplots(1, 3, figsize=(15, 6))
pr_axes[0].imshow(pd_mip, cmap='hot', aspect='equal')
pr_axes[0].set_title("projection density MaxIP")
pr_axes[1].imshow(ind_mip, cmap='hot', aspect='equal')
pr_axes[1].set_title("injection density MaxIP")
pr_axes[2].imshow(inf_mip, cmap='hot', aspect='equal')
pr_axes[2].set_title("injection fraction MaxIP")
# In[13]:
# Look at a slice from the average template and annotation volumes
# pick a slice to show
slice_idx = 264
f, ccf_axes = plt.subplots(1, 3, figsize=(15, 6))
ccf_axes[0].imshow(template[slice_idx,:,:], cmap='gray', aspect='equal', vmin=template.min(), vmax=template.max())
ccf_axes[0].set_title("registration template")
ccf_axes[1].imshow(annot[slice_idx,:,:], cmap='gray', aspect='equal', vmin=0, vmax=2000)
ccf_axes[1].set_title("annotation volume")
ccf_axes[2].imshow(cortex_mask[slice_idx,:,:], cmap='gray', aspect='equal', vmin=0, vmax=1)
ccf_axes[2].set_title("isocortex mask")
# On occasion the TissueCyte microscope fails to acquire a tile. In this case the data from that tile should not be used for analysis. The data mask associated with each experiment can be used to determine which portions of the grid data came from correctly acquired tiles.
#
# In this experiment, a missed tile can be seen in the data mask as a dark warped square. The values in the mask exist within [0, 1], describing the fraction of each voxel that was correctly acquired
# In[14]:
f, data_mask_axis = plt.subplots(figsize=(5, 6))
data_mask_axis.imshow(dm[81, :, :], cmap='hot', aspect='equal', vmin=0, vmax=1)
data_mask_axis.set_title('data mask')
def ontologies():
oa = OntologiesApi()
oa.json_msg_query = MagicMock(name='json_msg_query')
return oa