neurom.core.morphology

Morphology classes and functions.

Functions

graft_morphology(section)

Returns a morphology starting at section.

iter_neurites(obj[, mapfun, filt, neurite_order])

Iterator to a neurite, morphology or morphology population.

iter_points(obj[, neurite_filter, ...])

Return an iterator to the points in a population, morphology, neurites, or section.

iter_sections(neurites[, iterator_type, ...])

Iterator to the sections in a neurite, morphology or morphology population.

iter_segments(obj[, neurite_filter, ...])

Return an iterator to the segments in a collection of neurites.

Classes

Morphology(morphio_morph[, name, ...])

Class representing a simple morphology.

Neurite(root_node, *[, process_subtrees])

Class representing a neurite tree.

Section(morphio_section)

Simple recursive tree class.
class neurom.core.morphology.Morphology(morphio_morph, name=None, *, process_subtrees=False)

Class representing a simple morphology.

Morphology constructor.

Parameters:

  • morphio_morph (morphio.Morphology|morphio.mut.Morphology) – a morphio object

  • name (str) – an optional morphology name

  • process_subtrees (bool) – enable mixed tree processing if set to True

copy()

Returns a shallow copy of the morphio morphology object.

property neurites

The list of neurites.

property points

Returns the list of points.

section(section_id)

Returns the section with the given id.

property sections

The array of all sections, excluding the soma.

property segments

The array of all segments of the sections.

to_morphio()

Returns the morphio morphology object.

transform(trans)

Return a copy of this morphology with a 3D transformation applied.

class neurom.core.morphology.Neurite(root_node, *, process_subtrees=False)

Class representing a neurite tree.

Constructor.

Parameters:

  • root_node (morphio.Section) – root section

  • process_subtrees (bool) – enable mixed tree processing if set to True

property area

Return the surface area of this neurite.

The area is defined as the sum of area of the sections.

is_heterogeneous() → bool

Returns true if the neurite consists of more that one section types.

property length

Returns the total length of this neurite.

The length is defined as the sum of lengths of the sections.

property morphio_root_node

Returns the morphio root section.

property points

Array with all the points in this neurite.

Note: Duplicate points at section bifurcations are removed

property process_subtrees

Enable mixed tree processing if set to True.

property root_node

The first section of the neurite.

property sections

The array of all sections.

property segments

The array of all segments of the neurite.

subtree_types

The types of the subtrees.

type

The type of the Neurite (which can be composite).

property volume

Return the volume of this neurite.

The volume is defined as the sum of volumes of the sections.

class neurom.core.morphology.Section(morphio_section)

Simple recursive tree class.

The section constructor.

property area

Return the surface area of this section.

The area is calculated from the segments, as defined by this section’s points

property children

Returns a list of child section.

ibifurcation_point(iter_mode=<function Section.ipreorder>)

Iterator to bifurcation points.

Parameters:

iter_mode – iteration mode. Default: ipreorder.

property id

Returns the section ID.

iforking_point(iter_mode=<function Section.ipreorder>)

Iterator to forking points.

Parameters:

iter_mode – iteration mode. Default: ipreorder.

ileaf()

Iterator to all leaves of a tree.

ipostorder()

Depth-first post-order iteration of tree nodes.

ipreorder()

Depth-first pre-order iteration of tree nodes.

is_bifurcation_point()

Is tree a bifurcation point?

is_forking_point()

Is this section a forking point?

is_homogeneous_point()

A section is homogeneous if it has the same type with its children.

is_leaf()

Is tree a leaf?

is_root()

Is tree the root node?

iupstream(stop_node=None)

Iterate from a tree node to the root nodes.

Parameters:

stop_node – Node to stop the upstream traversal. If None, it stops when parent is None.

property length

Return the path length of this section.

property parent

Returns the parent section if non root section else None.

property points

Returns the section list of points the NeuroM way (points + radius).

property segments

The array of all segments of the neurite.

to_morphio()

Returns the morphio section.

property type

Returns the section type.

property volume

Return the volume of this section.

The volume is calculated from the segments, as defined by this section’s points

neurom.core.morphology.graft_morphology(section)

Returns a morphology starting at section.

neurom.core.morphology.iter_neurites(obj, mapfun=None, filt=None, neurite_order=NeuriteIter.FileOrder)

Iterator to a neurite, morphology or morphology population.

Applies optional neurite filter and mapping functions.

Parameters:

  • obj – a neurite, morphology or morphology population.

  • mapfun – optional neurite mapping function.

  • filt – optional neurite filter function.

  • neurite_order (NeuriteIter) – order upon which neurites should be iterated - NeuriteIter.FileOrder: order of appearance in the file - NeuriteIter.NRN: NRN simulator order: soma -> axon -> basal -> apical

Examples

Get the number of points in each neurite in a morphology population

>>> from neurom.core.morphology import iter_neurites
>>> from neurom import load_morphologies
>>> pop = load_morphologies("tests/data/valid_set")
>>> n_points = [n for n in iter_neurites(pop, lambda x, section_type: len(x.points))]

Get the number of points in each axon in a morphology population

>>> import neurom as nm
>>> from neurom.core.morphology import iter_neurites
>>> from neurom import load_morphologies
>>> pop = load_morphologies("tests/data/valid_set")
>>> filter = lambda n : n.type == nm.AXON
>>> mapping = lambda n, section_type: len(n.points)
>>> n_points = [n for n in iter_neurites(pop, mapping, filter)]
neurom.core.morphology.iter_points(obj, neurite_filter=None, neurite_order=NeuriteIter.FileOrder, section_filter=None)

Return an iterator to the points in a population, morphology, neurites, or section.

Parameters:

  • obj – population, morphology, neurite, section or iterable containing

  • neurite_filter – optional top level filter on properties of neurite neurite objects

  • neurite_order – order upon which neurite should be iterated. Values: - NeuriteIter.FileOrder: order of appearance in the file - NeuriteIter.NRN: NRN simulator order: soma -> axon -> basal -> apical

  • section_filter – optional section level filter

neurom.core.morphology.iter_sections(neurites, iterator_type=<function Section.ipreorder>, neurite_filter=None, neurite_order=NeuriteIter.FileOrder, section_filter=None)

Iterator to the sections in a neurite, morphology or morphology population.

Parameters:

  • neurites – morphology, population, neurite, or iterable containing neurite objects

  • iterator_type – section iteration order within a given neurite. Must be one of: Section.ipreorder: Depth-first pre-order iteration of tree nodes Section.ipostorder: Depth-first post-order iteration of tree nodes Section.iupstream: Iterate from a tree node to the root nodes Section.ibifurcation_point: Iterator to bifurcation points Section.ileaf: Iterator to all leaves of a tree

  • neurite_filter – optional top level filter on properties of neurite neurite objects.

  • neurite_order (NeuriteIter) – order upon which neurites should be iterated - NeuriteIter.FileOrder: order of appearance in the file - NeuriteIter.NRN: NRN simulator order: soma -> axon -> basal -> apical

  • section_filter – optional section level filter. Please note that neurite_filter takes precedence over the section_filter.

Examples

Get the number of points in each section of all the axons in a morphology population

>>> import neurom as nm
>>> from neurom.core.morphology import iter_sections
>>> filter = lambda n : n.type == nm.AXON
>>> n_points = [len(s.points) for s in iter_sections(pop,  neurite_filter=filter)]
neurom.core.morphology.iter_segments(obj, neurite_filter=None, neurite_order=NeuriteIter.FileOrder, section_filter=None, section_iterator=<function Section.ipreorder>)

Return an iterator to the segments in a collection of neurites.

Parameters:

  • obj – morphology, population, neurite, section, or iterable containing neurite objects

  • neurite_filter – optional top level filter on properties of neurite neurite objects

  • neurite_order – order upon which neurite should be iterated. Values: - NeuriteIter.FileOrder: order of appearance in the file - NeuriteIter.NRN: NRN simulator order: soma -> axon -> basal -> apical

  • section_filter – optional section level filter

  • section_iterator – section iteration order within a given neurite. Must be one of: Section.ipreorder: Depth-first pre-order iteration of tree nodes Section.ipostorder: Depth-first post-order iteration of tree nodes Section.iupstream: Iterate from a tree node to the root nodes Section.ibifurcation_point: Iterator to bifurcation points Section.ileaf: Iterator to all leaves of a tree

Note

This is a convenience function provided for generic access to morphology segments. It may have a performance overhead WRT custom-made segment analysis functions that leverage numpy and section-wise iteration.