Python neurom.load_neuron函数代码示例

def test_translate_fst_neuron_h5():

    t = np.array([100.,100.,100.])
    nrn = load_neuron(H5_NRN_PATH)
    tnrn = gtr.translate(nrn, t)

    _check_fst_nrn_translate(nrn, tnrn, t)

def test_translate_fst_neurite_h5():

    t = np.array([100.,100.,100.])
    nrn = load_neuron(H5_NRN_PATH)
    nrt_a = nrn.neurites[0]
    nrt_b = gtr.translate(nrt_a, t)
    _check_fst_neurite_translate(nrt_a, nrt_b, t)

def view(input_file, plane, backend):
    '''A simple neuron viewer'''
    if backend == 'matplotlib':
        from neurom.viewer import draw
        kwargs = {
            'mode': '3d' if plane == '3d' else '2d',
        }
        if plane != '3d':
            kwargs['plane'] = plane
        draw(load_neuron(input_file), **kwargs)
    else:
        from neurom.view.plotly import draw
        draw(load_neuron(input_file), plane=plane)

    if backend == 'matplotlib':
        import matplotlib.pyplot as plt
        plt.show()

def test_terminal_length_per_neurite():
    nrn = nm.load_neuron(os.path.join(SWC_PATH, 'simple.swc'))
    terminal_distances = np.array(_nf.terminal_path_lengths_per_neurite(nrn))
    np.testing.assert_allclose(terminal_distances,
                               np.array([5 + 5., 5 + 6., 4. + 6., 4. + 5]))
    terminal_distances = np.array(_nf.terminal_path_lengths_per_neurite(
        nrn, neurite_type=nm.AXON))
    np.testing.assert_allclose(terminal_distances,
                               np.array([4. + 6., 4. + 5.]))

 def setUp(self):
     self.ref_nrn = 'swc'
     self.sec_nrn = nm.load_neuron(os.path.join(SWC_DATA_PATH, SWC_MORPH_FILENAME))
     self.sec_nrn_trees = [n.root_node for n in self.sec_nrn.neurites]
     self.ref_types = [NeuriteType.axon,
                       NeuriteType.basal_dendrite,
                       NeuriteType.basal_dendrite,
                       NeuriteType.apical_dendrite,
                       ]

def test_get_nonmonotonic_neurites():

    n = load_neuron(os.path.join(SWC_PATH, 'Neuron.swc'))

    nt.assert_equal(len(mt.get_nonmonotonic_neurites(n)), 4)

    _make_monotonic(n)

    nt.assert_equal(len(mt.get_nonmonotonic_neurites(n)), 0)

def test_principal_direction_extents():
    # test with a realistic neuron
    nrn = nm.load_neuron(os.path.join(H5_PATH, 'bio_neuron-000.h5'))

    p_ref = [1672.9694359427331, 142.43704397865031, 226.45895382204986,
             415.50612748523838, 429.83008974193206, 165.95410536922873,
             346.83281498399697]

    p = _nf.principal_direction_extents(nrn)
    _close(np.array(p), np.array(p_ref))

def test_extract_stats_single_neuron():
    nrn = nm.load_neuron(os.path.join(DATA_PATH, 'Neuron.swc'))
    res = ms.extract_stats(nrn, REF_CONFIG)
    nt.eq_(res.keys(), REF_OUT.keys())
    nt.assert_almost_equal(res['mean_soma_radius'], REF_OUT['mean_soma_radius'])

    for k in ('all', 'axon', 'basal_dendrite', 'apical_dendrite'):
        nt.eq_(res[k].keys(), REF_OUT[k].keys())
        for kk in res[k].keys():
            nt.assert_almost_equal(res[k][kk], REF_OUT[k][kk])

def test_get_flat_neurites():

    n = load_neuron(os.path.join(SWC_PATH, 'Neuron.swc'))

    nt.assert_equal(len(mt.get_flat_neurites(n, 1e-6, method='tolerance')), 0)
    nt.assert_equal(len(mt.get_flat_neurites(n, 0.1, method='ratio')), 0)

    n = _make_flat(n)

    nt.assert_equal(len(mt.get_flat_neurites(n, 1e-6, method='tolerance')), 4)
    nt.assert_equal(len(mt.get_flat_neurites(n, 0.1, method='ratio')), 4)

def test_extract_stats_single_neuron():
    nrn = nm.load_neuron(os.path.join(DATA_PATH, 'Neuron.swc'))
    res = ms.extract_stats(nrn, REF_CONFIG)
    nt.eq_(set(res.keys()), set(REF_OUT.keys()))
    #Note: soma radius is calculated from the sphere that gives the area
    # of the cylinders described in Neuron.swc
    nt.assert_almost_equal(res['mean_soma_radius'], REF_OUT['mean_soma_radius'])

    for k in ('all', 'axon', 'basal_dendrite', 'apical_dendrite'):
        nt.eq_(set(res[k].keys()), set(REF_OUT[k].keys()))
        for kk in res[k].keys():
            nt.assert_almost_equal(res[k][kk], REF_OUT[k][kk])

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 test_has_no_narrow_dendritic_section():
    swc_content = StringIO(u"""
# index, type, x, y, z, radius, parent
    1 1  0  0 0 10. -1
    2 2  0  0 0 10.  1
    3 2  0  50 0 10.  2
    4 2 -5  51 0 10.  3
    5 2  6  53 0 10.  3
    6 3  0  0 0 5.  1  # start of the narrow section
    7 3  0 -4 0 5.  6
    8 3  6 -4 0 10.  7
    9 3 -5 -4 0 10.  7
""")
    nrn = load_neuron(swc_content, reader='swc')
    res = nrn_chk.has_no_narrow_neurite_section(nrn,
                                                dendrite_filter,
                                                radius_threshold=5,
                                                considered_section_min_length=0)

    nt.ok_(res.status)

    res = nrn_chk.has_no_narrow_neurite_section(nrn, dendrite_filter,
                                                radius_threshold=7,
                                                considered_section_min_length=0)
    nt.ok_(not res.status)

    swc_content = StringIO(u"""
# index, type, x, y, z, radius, parent
    1 1  0  0 0 10. -1
    2 2  0  0 0 5  1 # narrow soma
    3 2  0  50 0 5  2
    4 2 -5  51 0 5  3
    5 2  6  53 0 5  3
    6 3  0  0 0 5  1 # narrow axon
    7 3  0 -4 0 10.  6
    8 3  6 -4 0 10.  7
    9 3 -5 -4 0 10.  7
""")
    res = nrn_chk.has_no_narrow_neurite_section(nrn, dendrite_filter,
                                                radius_threshold=5,
                                                considered_section_min_length=0)
    nt.ok_(res.status, 'Narrow soma or axons should not raise bad status when checking for narrow dendrites')

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)

import numpy as np

_path = os.path.dirname(os.path.abspath(__file__))
DATA_PATH = os.path.join(_path, '../test_data')
SWC_PATH = os.path.join(DATA_PATH, 'swc')


def random_color():
    '''Random color generation'''
    return np.random.rand(3, 1)


def plot_somas(somas):
    '''Plot set of somas on same figure as spheres, each with different color'''
    _, ax = common.get_figure(new_fig=True, subplot=111,
                              params={'projection': '3d', 'aspect': 'equal'})
    for s in somas:
        common.plot_sphere(ax, s.center, s.radius, color=random_color(), alpha=1)
    plt.show()


if __name__ == '__main__':
    #  define set of files containing relevant neurons
    file_nms = [os.path.join(SWC_PATH, file_nm) for file_nm in ['Soma_origin.swc',
                                                                'Soma_translated_1.swc',
                                                                'Soma_translated_2.swc']]

    # load from file and plot
    sms = [load_neuron(file_nm).soma for file_nm in file_nms]
    plot_somas(sms)