def test_remote_bifurcation_angles():
ref_remote_bifangles = list(nf.remote_bifurcation_angles(NEURON))
remote_bifangles = get_feature('remote_bifurcation_angles', NEURON)
assert len(remote_bifangles) == 40
assert_allclose(remote_bifangles, ref_remote_bifangles)
remote_bifangles = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.all)
assert len(remote_bifangles) == 40
assert_allclose(remote_bifangles, ref_remote_bifangles)
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.axon)
assert len(s) == 10
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.basal_dendrite)
assert len(s) == 20
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.apical_dendrite)
assert len(s) == 10
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)
assert np.all(rad_dists == ref_segs)
assert np.all(rad_dists_origin == ref_segs_origin)
assert 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 test_register_neurite_feature_pop():
def npts(neurite):
return len(neurite.points)
def vol(neurite):
return neurite.volume
features.register_neurite_feature('foo', npts)
n_points_ref = [len(n.points) for n in iter_neurites(POP)]
n_points = get_feature('foo', POP)
assert_items_equal(n_points, n_points_ref)
# test neurite type filtering
n_points_ref = [
len(n.points)
for n in iter_neurites(POP, filt=_is_type(NeuriteType.basal_dendrite))
]
n_points = get_feature('foo', POP, neurite_type=NeuriteType.basal_dendrite)
assert_items_equal(n_points, n_points_ref)
features.register_neurite_feature('bar', vol)
n_volume_ref = [n.volume for n in iter_neurites(POP)]
n_volume = get_feature('bar', POP)
assert_items_equal(n_volume, n_volume_ref)
# test neurite type filtering
n_volume_ref = [
n.volume
for n in iter_neurites(POP, filt=_is_type(NeuriteType.basal_dendrite))
]
n_volume = get_feature('bar', POP, neurite_type=NeuriteType.basal_dendrite)
assert_items_equal(n_volume, n_volume_ref)
def test_section_lengths_invalid():
s = get_feature('section_lengths', NEURON, neurite_type=NeuriteType.soma)
assert len(s) == 0
s = get_feature('section_lengths',
NEURON,
neurite_type=NeuriteType.undefined)
assert len(s) == 0
def test_register_neurite_feature_nrns():
def npts(neurite):
return len(neurite.points)
def vol(neurite):
return neurite.volume
features.register_neurite_feature('foo', npts)
n_points_ref = [len(n.points) for n in iter_neurites(NRNS)]
n_points = get_feature('foo', NRNS)
assert_items_equal(n_points, n_points_ref)
# test neurite type filtering
n_points_ref = [
len(n.points)
for n in iter_neurites(NRNS, filt=_is_type(NeuriteType.axon))
]
n_points = get_feature('foo', NRNS, neurite_type=NeuriteType.axon)
assert_items_equal(n_points, n_points_ref)
features.register_neurite_feature('bar', vol)
n_volume_ref = [n.volume for n in iter_neurites(NRNS)]
n_volume = get_feature('bar', NRNS)
assert_items_equal(n_volume, n_volume_ref)
# test neurite type filtering
n_volume_ref = [
n.volume for n in iter_neurites(NRNS, filt=_is_type(NeuriteType.axon))
]
n_volume = get_feature('bar', NRNS, neurite_type=NeuriteType.axon)
assert_items_equal(n_volume, n_volume_ref)
def test_neurite_density_pop():
feat = 'neurite_volume_density'
assert_allclose(_stats(get_feature(feat, POP)),
(6.1847539631150784e-06, 0.52464681266899216,
1.9767794901940539, 0.19767794901940539))
assert_allclose(
_stats(get_feature(feat, POP, neurite_type=NeuriteType.all)),
(6.1847539631150784e-06, 0.52464681266899216, 1.9767794901940539,
0.19767794901940539))
assert_allclose(_stats(
get_feature(feat, POP, neurite_type=NeuriteType.axon)),
(6.1847539631150784e-06, 0.26465213325053372,
0.5275513670655404, 0.17585045568851346),
rtol=1e-6)
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.basal_dendrite)),
(0.00034968816544949771, 0.52464681266899216, 1.0116620531455183,
0.16861034219091972))
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.apical_dendrite)),
(0.43756606998299519, 0.43756606998299519, 0.43756606998299519,
0.43756606998299519))
def test_neurite_density_nrn():
feat = 'neurite_volume_density'
assert_allclose(_stats(get_feature(feat, NRN)),
(0.24068543213643726, 0.52464681266899216,
1.4657913638494682, 0.36644784096236704))
assert_allclose(
_stats(get_feature(feat, NRN, neurite_type=NeuriteType.all)),
(0.24068543213643726, 0.52464681266899216, 1.4657913638494682,
0.36644784096236704))
assert_allclose(
_stats(get_feature(feat, NRN, neurite_type=NeuriteType.axon)),
(0.26289304906104355, 0.26289304906104355, 0.26289304906104355,
0.26289304906104355))
assert_allclose(
_stats(get_feature(feat, NRN,
neurite_type=NeuriteType.basal_dendrite)),
(0.24068543213643726, 0.52464681266899216, 0.76533224480542938,
0.38266612240271469))
assert_allclose(
_stats(get_feature(feat, NRN,
neurite_type=NeuriteType.apical_dendrite)),
(0.43756606998299519, 0.43756606998299519, 0.43756606998299519,
0.43756606998299519))
def test_neurite_volumes_pop():
feat = 'neurite_volumes'
assert_allclose(_stats(get_feature(feat, POP)),
(28.356406629821159, 281.24754646913954,
2249.4613918388391, 224.9461391838839))
assert_allclose(
_stats(get_feature(feat, POP, neurite_type=NeuriteType.all)),
(28.356406629821159, 281.24754646913954, 2249.4613918388391,
224.9461391838839))
assert_allclose(
_stats(get_feature(feat, POP, neurite_type=NeuriteType.axon)),
(276.58135508666612, 277.5357232437392, 830.85568094763551,
276.95189364921185))
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.basal_dendrite)),
(28.356406629821159, 281.24754646913954, 1146.6644894516851,
191.1107482419475))
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.apical_dendrite)),
(271.94122143951864, 271.94122143951864, 271.94122143951864,
271.94122143951864))
def test_neurite_volumes_nrn():
feat = 'neurite_volumes'
assert_allclose(_stats(get_feature(feat, NRN)),
(271.9412, 281.2475, 1104.907, 276.2269),
rtol=1e-5)
assert_allclose(_stats(get_feature(feat, NRN,
neurite_type=NeuriteType.all)),
(271.9412, 281.2475, 1104.907, 276.2269),
rtol=1e-5)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.axon)),
(276.7386, 276.7386, 276.7386, 276.7386),
rtol=1e-5)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.basal_dendrite)),
(274.9803, 281.2475, 556.2279, 278.1139),
rtol=1e-5)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.apical_dendrite)),
(271.9412, 271.9412, 271.9412, 271.9412),
rtol=1e-5)
def test_remote_bifurcation_angles_invalid():
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.soma)
nt.eq_(len(s), 0)
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.undefined)
nt.eq_(len(s), 0)
def test_section_number_invalid():
nt.eq_(
get_feature('number_of_sections',
NEURON,
neurite_type=NeuriteType.soma)[0], 0)
nt.eq_(
get_feature('number_of_sections',
NEURON,
neurite_type=NeuriteType.undefined)[0], 0)
def test_remote_bifurcation_angles_invalid():
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.soma)
assert len(s) == 0
s = get_feature('remote_bifurcation_angles',
NEURON,
neurite_type=NeuriteType.undefined)
assert len(s) == 0
def test_segment_lengths():
ref_seglen = nf.segment_lengths(NEURON)
seglen = get_feature('segment_lengths', NEURON)
nt.eq_(len(seglen), 840)
assert_allclose(seglen, ref_seglen)
seglen = get_feature('segment_lengths',
NEURON,
neurite_type=NeuriteType.all)
nt.eq_(len(seglen), 840)
assert_allclose(seglen, ref_seglen)
def test_max_radial_distance():
feat = 'max_radial_distance'
neurites = POP[0].neurites
expected = {
None: 99.58945832,
NeuriteType.all: 99.58945832,
NeuriteType.apical_dendrite: 99.589458,
}
for neurite_type, expected_values in expected.items():
if neurite_type is None:
res = get_feature(feat, neurites)
else:
res = get_feature(feat, neurites, neurite_type=neurite_type)
assert_allclose(res, expected_values)
def test_section_radial_distances_origin():
origin = (-100, -200, -300)
ref_sec_rad_dist_origin = nf.section_radial_distances(NEURON,
origin=origin)
rad_dists = get_feature('section_radial_distances', NEURON, origin=origin)
nt.eq_(len(rad_dists), 84)
nt.ok_(np.all(rad_dists == ref_sec_rad_dist_origin))
def test_partition_asymmetry():
assert_allclose(
get_feature('partition_asymmetry', NRNS)[:10],
np.array([
0.9, 0.88888889, 0.875, 0.85714286, 0.83333333, 0.8, 0.75,
0.66666667, 0.5, 0.
]))
def test_section_radial_distances_origin():
origin = (-100, -200, -300)
ref_sec_rad_dist_origin = nf.section_radial_distances(NEURON,
origin=origin)
rad_dists = get_feature('section_radial_distances', NEURON, origin=origin)
assert len(rad_dists) == 84
assert np.all(rad_dists == ref_sec_rad_dist_origin)
def test_section_path_distances_start_point():
ref_sec_path_len_start = list(
iter_neurites(NEURON, sec.start_point_path_length))
path_lengths = get_feature('section_path_distances',
NEURON,
use_start_point=True)
assert len(path_lengths) == 84
assert np.all(path_lengths == ref_sec_path_len_start)
def test_neurite_features_accept_single_tree():
features = NEURITEFEATURES.keys()
for f in features:
ret = get_feature(f, NRN.neurites[0])
nt.ok_(ret.dtype.kind in ('i', 'f'))
nt.ok_(len(ret) or len(ret) == 0) # make sure that len() resolves
def test_neurite_number():
nt.eq_(get_feature('number_of_neurites', NEURON)[0], 4)
nt.eq_(
get_feature('number_of_neurites', NEURON,
neurite_type=NeuriteType.all)[0], 4)
nt.eq_(
get_feature('number_of_neurites',
NEURON,
neurite_type=NeuriteType.axon)[0], 1)
nt.eq_(
get_feature('number_of_neurites',
NEURON,
neurite_type=NeuriteType.basal_dendrite)[0], 2)
nt.eq_(
get_feature('number_of_neurites',
NEURON,
neurite_type=NeuriteType.apical_dendrite)[0], 1)
nt.eq_(
get_feature('number_of_neurites',
NEURON,
neurite_type=NeuriteType.soma)[0], 0)
nt.eq_(
get_feature('number_of_neurites',
NEURON,
neurite_type=NeuriteType.undefined)[0], 0)
def test_section_path_distances_start_point():
ref_sec_path_len_start = list(
iter_neurites(NEURON, sec.start_point_path_length))
path_lengths = get_feature('section_path_distances',
NEURON,
use_start_point=True)
nt.eq_(len(path_lengths), 84)
nt.ok_(np.all(path_lengths == ref_sec_path_len_start))
def test_section_path_distances_endpoint():
ref_sec_path_len_start = list(
iter_neurites(NEURON, sec.start_point_path_length))
ref_sec_path_len = list(iter_neurites(NEURON, sec.end_point_path_length))
path_lengths = get_feature('section_path_distances', NEURON)
assert ref_sec_path_len != ref_sec_path_len_start
assert len(path_lengths) == 84
assert np.all(path_lengths == ref_sec_path_len)
def test_section_path_distances_endpoint():
ref_sec_path_len_start = list(
iter_neurites(NEURON, sec.start_point_path_length))
ref_sec_path_len = list(iter_neurites(NEURON, sec.end_point_path_length))
path_lengths = get_feature('section_path_distances', NEURON)
nt.ok_(ref_sec_path_len != ref_sec_path_len_start)
nt.eq_(len(path_lengths), 84)
nt.ok_(np.all(path_lengths == ref_sec_path_len))
def test_neurite_features_accept_single_tree():
for f in NEURITEFEATURES:
ret = get_feature(f, NRN.neurites[0])
if isinstance(ret, np.ndarray):
assert ret.dtype.kind in ('i', 'f')
assert len(features._find_feature_func(f).shape) >= 1
assert len(ret) > 0
else:
assert np.isscalar(ret)
def test_get_trunk_section_lengths():
assert_allclose(get_feature('trunk_section_lengths', NEURON), [
9.579117366740002, 7.972322416776259, 8.2245287740603779,
9.212707985134525
])
assert_allclose(
get_feature('trunk_section_lengths',
NEURON,
neurite_type=NeuriteType.apical_dendrite),
[9.212707985134525])
assert_allclose(
get_feature('trunk_section_lengths',
NEURON,
neurite_type=NeuriteType.basal_dendrite),
[7.972322416776259, 8.2245287740603779])
assert_allclose(
get_feature('trunk_section_lengths',
NEURON,
neurite_type=NeuriteType.axon), [9.579117366740002])
def test_trunk_origin_radii():
assert_allclose(get_feature('trunk_origin_radii', NEURON), [
0.85351288499400002, 0.18391483031299999, 0.66943255462899998,
0.14656092843999999
])
assert_allclose(
get_feature('trunk_origin_radii',
NEURON,
neurite_type=NeuriteType.apical_dendrite),
[0.14656092843999999])
assert_allclose(
get_feature('trunk_origin_radii',
NEURON,
neurite_type=NeuriteType.basal_dendrite),
[0.18391483031299999, 0.66943255462899998])
assert_allclose(
get_feature('trunk_origin_radii',
NEURON,
neurite_type=NeuriteType.axon), [0.85351288499400002])
def test_section_tortuosity_nrn():
feat = 'section_tortuosity'
assert_allclose(_stats(get_feature(feat, NRN)),
(1.070, 1.573, 106.424, 1.266),
rtol=1e-3)
assert_allclose(_stats(get_feature(feat, NRN,
neurite_type=NeuriteType.all)),
(1.070, 1.573, 106.424, 1.266),
rtol=1e-3)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.apical_dendrite)),
(1.070, 1.573, 26.919, 1.281),
rtol=1e-3)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.basal_dendrite)),
(1.078, 1.550, 51.540, 1.227),
rtol=1e-3)
def test_segment_meander_angles_single_section():
feat = 'segment_meander_angles'
nrn = nm.load_neuron(StringIO(u"""((CellBody) (0 0 0 0))
((Dendrite)
(0 0 0 2)
(1 0 0 2)
(1 1 0 2)
(2 1 0 2)
(2 2 0 2)))"""),
reader='asc')
nrt = nrn.neurites[0]
pop = core.Population([nrn])
ref = [math.pi / 2, math.pi / 2, math.pi / 2]
nt.eq_(ref, get_feature(feat, nrt).tolist())
nt.eq_(ref, get_feature(feat, nrn).tolist())
nt.eq_(ref, get_feature(feat, pop).tolist())
def test_segment_meander_angles_nrn():
feat = 'segment_meander_angles'
assert_allclose(_stats(get_feature(feat, NRN)),
(0.32610, 3.12996, 1842.35, 2.43697),
rtol=1e-5)
assert_allclose(_stats(get_feature(feat, NRN,
neurite_type=NeuriteType.all)),
(0.32610, 3.12996, 1842.35, 2.43697),
rtol=1e-5)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.apical_dendrite)),
(0.32610, 3.09392, 461.981, 2.44434),
rtol=1e-5)
assert_allclose(_stats(
get_feature(feat, NRN, neurite_type=NeuriteType.basal_dendrite)),
(0.47318, 3.12996, 926.338, 2.45063),
rtol=1e-4)
def test_segment_meander_angles_pop():
feat = 'segment_meander_angles'
assert_allclose(
_stats(get_feature(feat, POP)),
(0.0, 3.1415926535897931, 14637.977670710961, 2.3957410263029395))
assert_allclose(
_stats(get_feature(feat, POP, neurite_type=NeuriteType.all)),
(0.0, 3.1415926535897931, 14637.977670710961, 2.3957410263029395))
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.apical_dendrite)),
(0.326101999292573, 3.0939261437163492, 461.98168732359414,
2.4443475519766884))
assert_allclose(
_stats(get_feature(feat, POP,
neurite_type=NeuriteType.basal_dendrite)),
(0.0, 3.1415926535897931, 2926.2411975307768, 2.4084289691611334))
