NeuroM 0.1.0¶

>>> from neurom import fst
>>> nrn = fst.load_neuron('some/data/path/morph_file.swc')
>>> ap_seg_len = fst.get('segment_lengths', nrn, neurite_type=fst.NeuriteType.apical_dendrite)
>>> ax_sec_len = fst.get('section_lengths', nrn, neurite_type=fst.NeuriteType.axon)

>>> # Initialize nrn as above
>>> from neurom import viewer
>>> fig, ax = viewer.draw(nrn)
>>> fig.show()
>>> fig, ax = viewer.draw(nrn, mode='3d') # valid modes '2d', '3d', 'dendrogram'
>>> fig.show()

'''Easy analysis examples

These examples highlight most of the pre-packaged neurom.fst.get
morphometrics functionality.

'''

from __future__ import print_function
from pprint import pprint
import numpy as np
from neurom import fst


def stats(data):
    '''Dictionary with summary stats for data

    Returns:
        dicitonary with length, mean, sum, standard deviation,\
            min and max of data
    '''
    return {'len': len(data),
            'mean': np.mean(data),
            'sum': np.sum(data),
            'std': np.std(data),
            'min': np.min(data),
            'max': np.max(data)}


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 = fst.load_neuron(filename)

    # Get some soma information
    # Soma radius and surface area
    print("Soma radius", fst.get('soma_radii', nrn)[0])
    print("Soma surface area", fst.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):', fst.get('number_of_neurites', nrn)[0])
    print('Number of neurites (axons):',
          fst.get('number_of_neurites', nrn, neurite_type=fst.NeuriteType.axon)[0])
    print('Number of neurites (apical dendrites):',
          fst.get('number_of_neurites', nrn, neurite_type=fst.NeuriteType.apical_dendrite)[0])
    print('Number of neurites (basal dendrites):',
          fst.get('number_of_neurites', nrn, neurite_type=fst.NeuriteType.basal_dendrite)[0])

    # number of sections
    print('Number of sections:',
          fst.get('number_of_sections', nrn)[0])
    print('Number of sections (axons):',
          fst.get('number_of_sections', nrn, neurite_type=fst.NeuriteType.axon)[0])
    print('Number of sections (apical dendrites):',
          fst.get('number_of_sections', nrn, neurite_type=fst.NeuriteType.apical_dendrite)[0])
    print('Number of sections (basal dendrites):',
          fst.get('number_of_sections', nrn, neurite_type=fst.NeuriteType.basal_dendrite)[0])

    # number of sections per neurite
    print('Number of sections per neurite:',
          fst.get('number_of_sections_per_neurite', nrn))
    print('Number of sections per neurite (axons):',
          fst.get('number_of_sections_per_neurite', nrn, neurite_type=fst.NeuriteType.axon))
    print('Number of sections per neurite (apical dendrites):',
          fst.get('number_of_sections_per_neurite',
                  nrn, neurite_type=fst.NeuriteType.apical_dendrite))
    print('Number of sections per neurite (basal dendrites):',
          fst.get('number_of_sections_per_neurite',
                  nrn, neurite_type=fst.NeuriteType.apical_dendrite))

    # OK, this is getting repetitive, so lets loop over valid neurite types.
    # The following methods return arrays of measurements. We will gather some
    # summary statistics for each and print them.

    # Section lengths for all and different types of neurite
    for ttype in fst.NEURITE_TYPES:
        sec_len = fst.get('section_lengths', nrn, neurite_type=ttype)
        print('Section lengths (', ttype, '):', sep='')
        pprint_stats(sec_len)

    # Segment lengths for all and different types of neurite
    for ttype in fst.NEURITE_TYPES:
        seg_len = fst.get('segment_lengths', nrn, neurite_type=ttype)
        print('Segment lengths (', ttype, '):', sep='')
        pprint_stats(seg_len)

    # Section radial distances for all and different types of neurite
    # Careful! Here we need to pass tree type as a named argument
    for ttype in fst.NEURITE_TYPES:
        sec_rad_dist = fst.get('section_radial_distances', nrn, neurite_type=ttype)
        print('Section radial distance (', ttype, '):', sep='')
        pprint_stats(sec_rad_dist)

    # Section path distances for all and different types of neurite
    # Careful! Here we need to pass tree type as a named argument
    for ttype in fst.NEURITE_TYPES:
        sec_path_dist = fst.get('section_path_distances', nrn, neurite_type=ttype)
        print('Section path distance (', ttype, '):', sep='')
        pprint_stats(sec_path_dist)

    # Local bifurcation angles for all and different types of neurite
    for ttype in fst.NEURITE_TYPES:
        local_bifangles = fst.get('local_bifurcation_angles', nrn, neurite_type=ttype)
        print('Local bifurcation angles (', ttype, '):', sep='')
        pprint_stats(local_bifangles)

    # Remote bifurcation angles for all and different types of neurite
    for ttype in fst.NEURITE_TYPES:
        rem_bifangles = fst.get('remote_bifurcation_angles', nrn, neurite_type=ttype)
        print('Local bifurcation angles (', ttype, '):', sep='')
        pprint_stats(rem_bifangles)

'''Advanced analysis examples

These examples highlight more advanced neurom
morphometrics functionality using iterators.

'''

from __future__ import print_function
from neurom import segments as seg
from neurom import sections as sec
from neurom import bifurcations as bif
from neurom import points as pts
from neurom import iter_neurites
from neurom.io.utils import load_neuron
from neurom.analysis.morphtree import set_tree_type
from neurom.core.types import tree_type_checker, NeuriteType, NEURITES
from neurom.analysis import morphtree as mt
import numpy as np


if __name__ == '__main__':

    filename = 'test_data/swc/Neuron.swc'

    #  load a neuron from an SWC file
    nrn = load_neuron(filename, set_tree_type)

    # Some examples of what can be done using iteration
    # instead of pre-packaged functions that return lists.
    # The iterations give us a lot of flexibility: we can map
    # any function that takes a segment or section.

    # Get length of all neurites in cell by iterating over sections,
    # and summing the section lengths
    print('Total neurite length:',
          sum(iter_neurites(nrn, sec.end_point_path_length)))

    # Get length of all neurites in cell by iterating over segments,
    # and summing the segment lengths.
    # This should yield the same result as iterating over sections.
    print('Total neurite length:',
          sum(iter_neurites(nrn, seg.length)))

    # get volume of all neurites in cell by summing over segment
    # volumes
    print('Total neurite volume:',
          sum(iter_neurites(nrn, seg.volume)))

    # get area of all neurites in cell by summing over segment
    # areas
    print('Total neurite surface area:',
          sum(iter_neurites(nrn, seg.area)))

    # get total number of points in cell.
    # iter_neurites needs a mapping function, so we pass the identity.
    print('Total number of points:',
          sum(1 for _ in iter_neurites(nrn, pts.identity)))

    # get mean radius of points in cell.
    # p[COLS.R] yields the radius for point p.
    print('Mean radius of points:',
          np.mean([r for r in iter_neurites(nrn, pts.radius)]))

    # get mean radius of segments
    print('Mean radius of segments:',
          np.mean(list(iter_neurites(nrn, seg.radius))))

    # get stats for the segment taper rate, for different types of neurite
    for ttype in NEURITES:
        ttt = ttype
        seg_taper_rate = list(iter_neurites(nrn, seg.taper_rate, tree_type_checker(ttt)))
        print('Segment taper rate (', ttype,
              '):\n  mean=', np.mean(seg_taper_rate),
              ', std=', np.std(seg_taper_rate),
              ', min=', np.min(seg_taper_rate),
              ', max=', np.max(seg_taper_rate),
              sep='')

    # Number of bifurcation points.
    print('Number of bifurcation points:', bif.count(nrn))

    # Number of bifurcation points for apical dendrites
    print('Number of bifurcation points (apical dendrites):',
          sum(1 for _ in iter_neurites(nrn, bif.identity,
                                       tree_type_checker(NeuriteType.apical_dendrite))))

    # Maximum branch order
    # We create a custom branch_order section_function
    # and use the generalized iteration method
    @sec.section_function(as_tree=True)
    def branch_order(s):
        '''Get the branch order of a section'''
        return mt.branch_order(s)

    print('Maximum branch order:',
          max(bo for bo in iter_neurites(nrn, branch_order)))

    # Neuron's bounding box
    print('Bounding box ((min x, y, z), (max x, y, z))',
          nrn.bounding_box())