def get_sholl_parts(neuron, step_size):
"""return a dataframe including sholl frequency of apical and basal dendrites
'step_size': the increasing radius (um)"""
shollf1 = nm.get(
"sholl_frequency",
neuron,
step_size=step_size,
neurite_type=nm.NeuriteType.apical_dendrite,
)
shollf2 = nm.get(
"sholl_frequency",
neuron,
step_size=step_size,
neurite_type=nm.NeuriteType.basal_dendrite,
)
r1 = np.arange(len(shollf1)) * step_size
r2 = np.arange(len(shollf2)) * step_size
df1 = pd.DataFrame(
{"radius": r1, "intersections": shollf1, "label": "apical", "id": neuron.name}
)
df2 = pd.DataFrame(
{"radius": r2, "intersections": shollf2, "label": "basal", "id": neuron.name}
)
df = pd.concat([df1, df2])
return df[df.intersections > 0]
def f3(name):
cur_res0=nm.get(name, neuron).sum()
cur_res1=nm.get(name, neuron, neurite_type=nm.APICAL_DENDRITE).sum()
cur_res2=nm.get(name, neuron, neurite_type=nm.BASAL_DENDRITE).sum()
yield (name, cur_res0)
yield (name+'(apical)', cur_res1)
yield (name+'(basal)', cur_res2)
def save_morph_data(self, morph_stats_filename):
if not os.path.exists(morph_stats_filename):
# load a neuron from an SWC file
nrn = nm.load_neuron(self.morph_file)
morph_stats = {}
morph_stats['cell_id'] = self.cell_id
morph_stats['soma_suface'] = nm.get('soma_surface_areas', nrn)[0]
morph_stats['soma_radius'] = np.mean(nm.get('soma_radii', nrn))
# Morph stats
for nrn_type_ in NEURITES:
morph_stats['length' + '.' +
str(nrn_type_).split('.')[1]] = np.sum(
nm.get('segment_lengths',
nrn,
neurite_type=nrn_type_))
morph_stats['area' + '.' + str(nrn_type_).split('.')[1]] = sum(
mm.segment_area(s) for s in nm.iter_segments(
nrn, neurite_filter=tree_type_checker(nrn_type_)))
morph_stats[
'volume' + '.' + str(nrn_type_).split('.')[1]] = sum(
mm.segment_volume(s) for s in nm.iter_segments(
nrn, neurite_filter=tree_type_checker(nrn_type_)))
morph_stats['taper_rate' + '.' + str(nrn_type_).split('.')[1]] = \
np.mean([mm.segment_taper_rate(s) for s in nm.iter_segments(
nrn, neurite_filter=tree_type_checker(nrn_type_))])
utility.save_json(morph_stats_filename, morph_stats)
def extract_stats(neurons, config):
'''Extract stats from neurons'''
stats = defaultdict(dict)
for ns, modes in config['neurite'].items():
for n in config['neurite_type']:
n = _NEURITE_MAP[n]
for mode in modes:
stat_name = _stat_name(ns, mode)
stat = eval_stats(nm.get(ns, neurons, neurite_type=n), mode)
if stat is None or len(stat.shape) == 0:
stats[n.name][stat_name] = stat
else:
assert stat.shape in ((3, ), ), \
'Statistic must create a 1x3 result'
for i, suffix in enumerate('XYZ'):
compound_stat_name = stat_name + '_' + suffix
stats[n.name][compound_stat_name] = stat[i]
for ns, modes in config['neuron'].items():
for mode in modes:
stat_name = _stat_name(ns, mode)
stats[stat_name] = eval_stats(nm.get(ns, neurons), mode)
return stats
def test_segment_radial_distances_origin():
origin = (-100, -200, -300)
ref_segs = nf.segment_radial_distances(NEURON)
ref_segs_origin = nf.segment_radial_distances(NEURON, origin=origin)
rad_dists = get_feature('segment_radial_distances', NEURON)
rad_dists_origin = get_feature('segment_radial_distances',
NEURON,
origin=origin)
nt.ok_(np.all(rad_dists == ref_segs))
nt.ok_(np.all(rad_dists_origin == ref_segs_origin))
nt.ok_(np.all(rad_dists_origin != ref_segs))
nrns = [
nm.load_neuron(Path(SWC_PATH, f))
for f in ('point_soma_single_neurite.swc',
'point_soma_single_neurite2.swc')
]
pop = Population(nrns)
rad_dist_nrns = []
for nrn in nrns:
rad_dist_nrns.extend(nm.get('segment_radial_distances', nrn))
rad_dist_nrns = np.array(rad_dist_nrns)
rad_dist_pop = nm.get('segment_radial_distances', pop)
assert_allclose(rad_dist_nrns, rad_dist_pop)
def extract_stats(neurons, config):
"""Extract stats from neurons."""
stats = defaultdict(dict)
def _fill_compoundified(data, stat_name, stat):
"""Insert the stat in the dict and eventually split it into XYZ components."""
if stat is None or not isinstance(
stat, np.ndarray) or stat.shape not in ((3, ), ):
data[stat_name] = stat
else:
for i, suffix in enumerate('XYZ'):
compound_stat_name = stat_name + '_' + suffix
data[compound_stat_name] = stat[i]
for (feature_name,
modes), neurite_type in product(config['neurite'].items(),
config['neurite_type']):
neurite_type = _NEURITE_MAP[neurite_type]
for mode in modes:
stat_name = _stat_name(feature_name, mode)
stat = eval_stats(
nm.get(feature_name, neurons, neurite_type=neurite_type), mode)
_fill_compoundified(stats[neurite_type.name], stat_name, stat)
for feature_name, modes in config['neuron'].items():
for mode in modes:
stat_name = _stat_name(feature_name, mode)
stat = eval_stats(nm.get(feature_name, neurons), mode)
_fill_compoundified(stats, stat_name, stat)
return stats
def extract_stats(neurons, config):
"""Extract stats from neurons.
Arguments:
neurons: a neuron, population, neurite tree or list of neuron paths/str
config (dict): configuration dict. The keys are:
- neurite_type: a list of neurite types for which features are extracted
If not provided, all neurite_type will be used
- neurite: a dictionary {{neurite_feature: mode}} where:
- neurite_feature is a string from NEURITEFEATURES
- mode is an aggregation operation provided as a string such as:
['min', 'max', 'median', 'mean', 'std', 'raw', 'total']
Returns:
The extracted statistics
Note:
An example config can be found at:
{config_path}
"""
def _fill_stats_dict(data, stat_name, stat):
"""Insert the stat data in the dict.
And if the stats is a 3D array, splits it into XYZ components.
"""
if stat is None or not isinstance(stat, np.ndarray) or stat.shape not in ((3, ), ):
data[stat_name] = stat
else:
for i, suffix in enumerate('XYZ'):
compound_stat_name = stat_name + '_' + suffix
data[compound_stat_name] = stat[i]
stats = defaultdict(dict)
for (feature_name, modes), neurite_type in product(config['neurite'].items(),
config.get('neurite_type',
_NEURITE_MAP.keys())):
neurite_type = _NEURITE_MAP[neurite_type]
feature = nm.get(feature_name, neurons, neurite_type=neurite_type)
for mode in modes:
stat_name = _stat_name(feature_name, mode)
stat = eval_stats(feature, mode)
_fill_stats_dict(stats[neurite_type.name], stat_name, stat)
for feature_name, modes in config.get('neuron', {}).items():
feature = nm.get(feature_name, neurons)
for mode in modes:
stat_name = _stat_name(feature_name, mode)
stat = eval_stats(feature, mode)
_fill_stats_dict(stats, stat_name, stat)
return dict(stats)
def f1_1(name,part='all'):
if part=='all':
cur_res = nm.get(name, neuron).mean()
cur_key = 'mean_' + name
elif part=='apical':
cur_res = nm.get(name, neuron, neurite_type=nm.APICAL_DENDRITE).mean()
cur_key = 'mean_' + name + '(apical)'
elif part=='basal':
cur_res = nm.get(name, neuron, neurite_type=nm.BASAL_DENDRITE).mean()
cur_key = 'mean_' + name + '(basal)'
yield (cur_key, cur_res)
def test_section_radial_distances_endpoint():
ref_sec_rad_dist = nf.section_radial_distances(NEURON)
rad_dists = fst_get('section_radial_distances', NEURON)
nt.eq_(len(rad_dists), 84)
nt.ok_(np.all(rad_dists == ref_sec_rad_dist))
nrns = [nm.load_neuron(os.path.join(SWC_PATH, f)) for
f in ('point_soma_single_neurite.swc', 'point_soma_single_neurite2.swc')]
pop = Population(nrns)
rad_dist_nrns = [nm.get('section_radial_distances', nrn) for nrn in nrns]
rad_dist_pop = nm.get('section_radial_distances', pop)
assert_items_equal(rad_dist_pop, rad_dist_nrns)
def test_section_radial_distances_endpoint():
ref_sec_rad_dist = nf.section_radial_distances(NEURON)
rad_dists = fst_get('section_radial_distances', NEURON)
nt.eq_(len(rad_dists), 84)
nt.ok_(np.all(rad_dists == ref_sec_rad_dist))
nrns = [nm.load_neuron(os.path.join(SWC_PATH, f)) for
f in ('point_soma_single_neurite.swc', 'point_soma_single_neurite2.swc')]
pop = Population(nrns)
rad_dist_nrns = [nm.get('section_radial_distances', nrn) for nrn in nrns]
rad_dist_pop = nm.get('section_radial_distances', pop)
assert_items_equal(rad_dist_pop, rad_dist_nrns)
def test_segment_radial_distances_displaced_neurite():
nrns = [nm.load_neuron(os.path.join(SWC_PATH, f)) for
f in ('point_soma_single_neurite.swc', 'point_soma_single_neurite2.swc')]
pop = Population(nrns)
rad_dist_nrns = []
for nrn in nrns:
rad_dist_nrns.extend( nm.get('segment_radial_distances', nrn))
rad_dist_nrns = np.array(rad_dist_nrns)
rad_dist_pop = nm.get('segment_radial_distances', pop)
nt.ok_(np.alltrue(rad_dist_pop == rad_dist_nrns))
def tree_asymmetry(neurite, neuron=None):
'''
Return the tree-assymetry of a neurite.
Parameters
----------
neurite : Neurite object or str
Neurite to analyze.
neuron : int, optional (default: None)
GID of the neuron if the neurite was passed as a str and not as an
object.
'''
try:
import neurom as nm
except ImportError:
raise ImportError("This function requires the `neurom` package "
"to work, please install it through, e.g. "
"`pip install --user neurom`.")
try:
tree = neurite.get_tree().neurom_tree()
except AttributeError:
nrn = _pg.get_neurons(neuron)[0]
tree = neurite.get_tree().neurom_tree()
asyms = nm.get("partition_asymmetry", tree)
return np.average(asyms) / _max_asym(len(neurite.get_tree().tips))
def histogram(neuron, feature, ax, bins=15, normed=True, cumulative=False):
'''
Plot a histogram of the selected feature for the population of neurons.
Plots x-axis versus y-axis on a scatter|histogram|binned values plot.
Parameters :
neurons : neuron list
feature : str
The feature of interest.
bins : int
Number of bins for the histogram.
cumulative : bool
Sets cumulative histogram on.
ax : axes object
the axes in which the plot is taking place
'''
feature_values = nm.get(feature, neuron)
# generate histogram
ax.hist(feature_values, bins=bins, cumulative=cumulative, normed=normed)
def histogram(neuron, feature, ax, bins=15, normed=True, cumulative=False):
'''
Plot a histogram of the selected feature for the population of neurons.
Plots x-axis versus y-axis on a scatter|histogram|binned values plot.
Parameters :
neurons : neuron list
feature : str
The feature of interest.
bins : int
Number of bins for the histogram.
cumulative : bool
Sets cumulative histogram on.
ax : axes object
the axes in which the plot is taking place
'''
feature_values = nm.get(feature, neuron)
# generate histogram
ax.hist(feature_values, bins=bins, cumulative=cumulative, normed=normed)
def create_recordings(cell):
"""Create the recordings"""
my_neuron = nm.load_neuron('morphology/C230300D1_-_Clone_5.asc')
num_axon_sec = len(
nm.get('section_lengths', my_neuron, neurite_type=nm.AXON))
print('Attaching recording electrodes')
recordings = {}
recordings['time'] = neuron.h.Vector()
recordings['soma(0.5)'] = neuron.h.Vector()
#recordings['axon35'] = neuron.h.Vector()
#recordings['axon67'] = neuron.h.Vector()
#recordings['axon124'] = neuron.h.Vector()
#recordings['axon106'] = neuron.h.Vector()
#d = {}
for i in range(num_axon_sec): # 171
recordings["v_vect" + str(i)] = neuron.h.Vector()
for i in range(num_axon_sec): # 171
recordings["v_vect" + str(i)].record(cell.axon[i](0.5)._ref_v, 0.025)
recordings['time'].record(neuron.h._ref_t, 0.025)
recordings['soma(0.5)'].record(cell.soma[0](0.5)._ref_v, 0.025)
#recordings['axon35'].record(cell.axon[35](0.5)._ref_v, 0.025)
#recordings['axon67'].record(cell.axon[67](0.5)._ref_v, 0.025)
#recordings['axon124'].record(cell.axon[124](0.5)._ref_v, 0.1)
#recordings['axon106'].record(cell.axon[106](0.5)._ref_v, 0.025)
return recordings
def test_section_radial_distances_endpoint():
ref_sec_rad_dist = nf.section_radial_distances(NEURON)
rad_dists = get_feature('section_radial_distances', NEURON)
assert len(rad_dists) == 84
assert np.all(rad_dists == ref_sec_rad_dist)
nrns = [
nm.load_neuron(Path(SWC_PATH, f))
for f in ('point_soma_single_neurite.swc',
'point_soma_single_neurite2.swc')
]
pop = Population(nrns)
rad_dist_nrns = [nm.get('section_radial_distances', nrn) for nrn in nrns]
rad_dist_pop = nm.get('section_radial_distances', pop)
assert_items_equal(rad_dist_pop, rad_dist_nrns)
def test_neuron_not_corrupted():
# Regression for #492: dendrogram was corrupting
# neuron used to construct it.
# This caused the section path distance calculation
# to raise a KeyError exception.
neuron = load_neuron(NEURON_PATH)
dm.Dendrogram(neuron)
assert get('section_path_distances', neuron).size > 0
def extract_stats(neurons, config):
'''Extract stats from neurons'''
stats = defaultdict(dict)
for ns, modes in config['neurite'].iteritems():
for n in config['neurite_type']:
n = _NEURITE_MAP[n]
for mode in modes:
stat_name = _stat_name(ns, mode)
stats[n.name][stat_name] = eval_stats(nm.get(ns, neurons, neurite_type=n), mode)
L.debug('Stat: %s, Neurite: %s, Type: %s',
stat_name, n, type(stats[n.name][stat_name]))
for ns, modes in config['neuron'].iteritems():
for mode in modes:
stat_name = _stat_name(ns, mode)
stats[stat_name] = eval_stats(nm.get(ns, neurons), mode)
return stats
def load_neurite_features(filepath):
"""Unpack relevant data into megadict"""
stuff = defaultdict(lambda: defaultdict(list))
nrns = nm.load_neurons(filepath)
# unpack data into arrays
for nrn in nrns:
for t in NEURITES_:
for feat in FEATURES:
stuff[feat][str(t).split(".")[1]].extend(nm.get(feat, nrn, neurite_type=t))
return stuff
def neuroMAnalysisForNeurons(fullState: FullState) -> pd.DataFrame:
result = pd.DataFrame()
neurons = [treeToNeuroM(fullState, tree) for tree in fullState.trees]
result['paths'] = [os.path.basename(path) for path in fullState.filePaths]
result['tdbl'] = [
np.sum(
nm.get('section_lengths', neuron, neurite_type=nm.BASAL_DENDRITE))
for neuron in neurons
]
return result
def load_neurite_features(filepath):
'''Unpack relevant data into megadict'''
stuff = defaultdict(lambda: defaultdict(list))
nrns = nm.load_neurons(filepath)
# unpack data into arrays
for nrn in nrns:
for t in NEURITES_:
for feat in FEATURES:
stuff[feat][str(t).split('.')[1]].extend(
nm.get(feat, nrn, neurite_type=t))
return stuff
def extract_data(data_path, feature):
'''Loads a list of neurons, extracts feature
and transforms the fitted distribution in the correct format.
Returns the optimal distribution, corresponding parameters,
minimun and maximum values.
'''
population = nm.load_neurons(data_path)
feature_data = [nm.get(feature, n) for n in population]
feature_data = list(chain(*feature_data))
return stats.optimal_distribution(feature_data)
def extract_data(data_path, feature):
'''Loads a list of neurons, extracts feature
and transforms the fitted distribution in the correct format.
Returns the optimal distribution, corresponding parameters,
minimun and maximum values.
'''
population = nm.load_neurons(data_path)
feature_data = [nm.get(feature, n) for n in population]
feature_data = list(chain(*feature_data))
return stats.optimal_distribution(feature_data)
def test_segment_radial_distances_origin():
origin = (-100, -200, -300)
ref_segs = nf.segment_radial_distances(NEURON)
ref_segs_origin = nf.segment_radial_distances(NEURON, origin=origin)
rad_dists = fst_get('segment_radial_distances', NEURON)
rad_dists_origin = fst_get('segment_radial_distances', NEURON, origin=origin)
nt.ok_(np.all(rad_dists == ref_segs))
nt.ok_(np.all(rad_dists_origin == ref_segs_origin))
nt.ok_(np.all(rad_dists_origin != ref_segs))
nrns = [nm.load_neuron(os.path.join(SWC_PATH, f)) for
f in ('point_soma_single_neurite.swc', 'point_soma_single_neurite2.swc')]
pop = Population(nrns)
rad_dist_nrns = []
for nrn in nrns:
rad_dist_nrns.extend(nm.get('segment_radial_distances', nrn))
rad_dist_nrns = np.array(rad_dist_nrns)
rad_dist_pop = nm.get('segment_radial_distances', pop)
assert_allclose(rad_dist_nrns, rad_dist_pop)
def test_load_neuron_mixed_tree_swc():
nrn_mix = utils.load_neuron(os.path.join(SWC_ORD_PATH, 'sample_mixed_tree_sections.swc'))
nt.assert_items_equal(get('number_of_sections_per_neurite', nrn_mix), [5, 3])
nt.assert_items_equal(get('number_of_sections_per_neurite', nrn_mix),
get('number_of_sections_per_neurite', SWC_ORD_REF))
nt.assert_items_equal(get('number_of_segments', nrn_mix),
get('number_of_segments', SWC_ORD_REF))
nt.assert_items_equal(get('total_length', nrn_mix),
get('total_length', SWC_ORD_REF))
def test_load_neuron_mixed_tree_swc():
nrn_mix = utils.load_neuron(os.path.join(SWC_ORD_PATH, 'sample_mixed_tree_sections.swc'))
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix), [5, 3])
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix),
get('number_of_sections_per_neurite', SWC_ORD_REF))
assert_items_equal(get('number_of_segments', nrn_mix),
get('number_of_segments', SWC_ORD_REF))
assert_items_equal(get('total_length', nrn_mix),
get('total_length', SWC_ORD_REF))
def extract_data(neurons, feature, params=None):
'''Extracts feature from a list of neurons
and transforms the fitted distribution in the correct format.
Returns the optimal distribution and corresponding parameters.
Normal distribution params (mean, std)
Exponential distribution params (loc, scale)
Uniform distribution params (min, range)
'''
if params is None:
params = {}
feature_data = [get(FEATURE_MAP[feature], n, **params) for n in neurons]
feature_data = list(chain(*feature_data))
return stats.optimal_distribution(feature_data)
def extract_data(neurons, feature, params=None):
'''Extracts feature from a list of neurons
and transforms the fitted distribution in the correct format.
Returns the optimal distribution and corresponding parameters.
Normal distribution params (mean, std)
Exponential distribution params (loc, scale)
Uniform distribution params (min, range)
'''
if params is None:
params = {}
feature_data = [get(FEATURE_MAP[feature], n, **params) for n in neurons]
feature_data = list(chain(*feature_data))
return stats.optimal_distribution(feature_data)
def test_load_neuron_section_order_break_swc():
nrn_mix = utils.load_neuron(os.path.join(SWC_ORD_PATH, 'sample_disordered.swc'))
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix), [5, 3])
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix),
get('number_of_sections_per_neurite', SWC_ORD_REF))
assert_items_equal(get('number_of_segments', nrn_mix),
get('number_of_segments', SWC_ORD_REF))
assert_items_equal(get('total_length', nrn_mix),
get('total_length', SWC_ORD_REF))
def test_load_neuron_section_order_break_swc():
nrn_mix = utils.load_neuron(Path(SWC_ORD_PATH, 'sample_disordered.swc'))
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix), [5, 3])
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix),
get('number_of_sections_per_neurite', SWC_ORD_REF))
assert_items_equal(get('number_of_segments', nrn_mix),
get('number_of_segments', SWC_ORD_REF))
assert_items_equal(get('total_length', nrn_mix),
get('total_length', SWC_ORD_REF))
def test_multiple_distr(filepath):
'''Runs the distribution fit for multiple distributions and returns
the optimal distribution along with the corresponding parameters.
'''
# load a neuron from an SWC file
population = nm.load_neurons(filepath)
# Create a list of basic distributions
distr_to_check = ('norm', 'expon', 'uniform')
# Get the soma radii of a population of neurons
soma_size = nm.get('soma_radii', population)
# Find the best fit distribution
return st.optimal_distribution(soma_size, distr_to_check)
def test_multiple_distr(filepath):
'''Runs the distribution fit for multiple distributions and returns
the optimal distribution along with the corresponding parameters.
'''
# load a neuron from an SWC file
population = nm.load_neurons(filepath)
# Create a list of basic distributions
distr_to_check = ('norm', 'expon', 'uniform')
# Get the soma radii of a population of neurons
soma_size = nm.get('soma_radii', population)
# Find the best fit distribution
return st.optimal_distribution(soma_size, distr_to_check)
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
'''Compatibility between NL and H5 files'''
# pylint: disable=protected-access
import numpy as np
import neurom as nm
from neurom.fst import _neuritefunc as _nf
nrn_h5 = nm.load_neuron('test_data/h5/v1/bio_neuron-001.h5')
nrn_asc = nm.load_neuron('test_data/neurolucida/bio_neuron-001.asc')
print 'h5 number of sections: %s' % nm.get('number_of_sections', nrn_h5)[0]
print 'nl number of sections: %s\n' % nm.get('number_of_sections', nrn_asc)[0]
print 'h5 number of segments: %s' % nm.get('number_of_segments', nrn_h5)[0]
print 'nl number of segments: %s\n' % nm.get('number_of_segments', nrn_asc)[0]
print 'h5 total neurite length: %s' % np.sum(nm.get('section_lengths', nrn_h5))
print 'nl total neurite length: %s\n' % np.sum(nm.get('section_lengths', nrn_asc))
print 'h5 principal direction extents: %s' % nm.get('principal_direction_extents', nrn_h5)
print 'nl principal direction extents: %s' % nm.get('principal_direction_extents', nrn_asc)
print '\nNumber of neurites:'
for nt in nm.NeuriteType:
print nt, _nf.n_neurites(nrn_h5, neurite_type=nt),\
_nf.n_neurites(nrn_asc, neurite_type=nt)
print '\nNumber of segments:'
for nt in nm.NeuriteType:
def time_segment_midpoints(self):
nm.get('segment_midpoints', self.neuron)
def pprint_stats(data):
'''Pretty print summary stats for data'''
pprint(stats(data))
if __name__ == '__main__':
filename = 'test_data/swc/Neuron.swc'
# load a neuron from an SWC file
nrn = nm.load_neuron(filename)
# Get some soma information
# Soma radius and surface area
print("Soma radius", nm.get('soma_radii', nrn)[0])
print("Soma surface area", nm.get('soma_surface_areas', nrn)[0])
# Get information about neurites
# Most neurite data can be queried for a particular type of neurite.
# The allowed types are members of the NeuriteType enumeration.
# NEURITE_TYPES is a list of valid neurite types.
# We start by calling methods for different neurite types separately
# to warm up...
# number of neurites
print('Number of neurites (all):', nm.get('number_of_neurites', nrn)[0])
print('Number of neurites (axons):',
nm.get('number_of_neurites', nrn, neurite_type=nm.NeuriteType.axon)[0])
print('Number of neurites (apical dendrites):',
def time_number_of_terminations(self):
nm.get('number_of_terminations', self.neuron)
def time_number_of_bifurcations(self):
nm.get('number_of_bifurcations', self.neuron)
def time_remote_bifurcation_angles(self):
nm.get('remote_bifurcation_angles', self.neuron)
def time_segment_lengths(self):
nm.get('segment_lengths', self.neuron)
def time_number_of_segments(self):
nm.get('number_of_segments', self.neuron)
def time_segment_taper_rates(self):
nm.get('segment_taper_rates', self.neuron)
def time_segment_midpoints(self):
nm.get('segment_midpoints', self.neuron)
def time_segment_radii(self):
nm.get('segment_radii', self.neuron)
def time_segment_lengths(self):
nm.get('segment_lengths', self.neuron)
def time_number_of_segments(self):
nm.get('number_of_segments', self.neuron)
def time_partition(self):
nm.get('partition', self.neuron)
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Compatibility between NL and H5 files."""
# pylint: disable=protected-access
import numpy as np
import neurom as nm
from neurom.features import neuritefunc as _nf
nrn_h5 = nm.load_neuron('tests/data/h5/v1/bio_neuron-001.h5')
nrn_asc = nm.load_neuron('tests/data/neurolucida/bio_neuron-001.asc')
print('h5 number of sections: %s' % nm.get('number_of_sections', nrn_h5)[0])
print('nl number of sections: %s\n' % nm.get('number_of_sections', nrn_asc)[0])
print('h5 number of segments: %s' % nm.get('number_of_segments', nrn_h5)[0])
print('nl number of segments: %s\n' % nm.get('number_of_segments', nrn_asc)[0])
print('h5 total neurite length: %s' %
np.sum(nm.get('section_lengths', nrn_h5)))
print('nl total neurite length: %s\n' %
np.sum(nm.get('section_lengths', nrn_asc)))
print('h5 principal direction extents: %s' %
nm.get('principal_direction_extents', nrn_h5))
print('nl principal direction extents: %s' %
nm.get('principal_direction_extents', nrn_asc))
print('\nNumber of neurites:')
for nt in iter(nm.NeuriteType):
print(nt, _nf.n_neurites(nrn_h5, neurite_type=nt), _nf.n_neurites(nrn_asc, neurite_type=nt))
def time_segment_radii(self):
nm.get('segment_radii', self.neuron)
def time_remote_bifurcation_angles(self):
nm.get('remote_bifurcation_angles', self.neuron)
def time_section_radial_distances(self):
nm.get('section_radial_distances', self.neuron)
def time_local_bifurcation_angles(self):
nm.get('local_bifurcation_angles', self.neuron)
def time_partition(self):
nm.get('partition', self.neuron)
def time_number_of_neurites(self):
nm.get('number_of_neurites', self.neuron)
def time_number_of_sections_per_neurite(self):
nm.get('number_of_sections_per_neurite', self.neuron)
def time_segment_taper_rates(self):
nm.get('segment_taper_rates', self.neuron)
def test_load_neuron_mixed_tree_h5():
nrn_mix = utils.load_neuron(Path(H5_PATH, 'sample_mixed_tree_sections.h5'))
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix), [5, 3])
assert_items_equal(get('number_of_sections_per_neurite', nrn_mix),
get('number_of_sections_per_neurite', H5_ORD_REF))
def test_neuron_not_corrupted(self):
# Regression for #492: dendrogram was corrupting
# neuron used to construct it.
# This caused the section path distance calculation
# to raise a KeyError exception.
get('section_path_distances', NEURON)
def time_section_branch_orders(self):
nm.get('section_branch_orders', self.neuron)
def time_number_of_forking_points(self):
nm.get('number_of_forking_points', self.neuron)
