morphology.h

#pragma once
 
#include <map>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include <morphio/errorMessages.h>
#include <morphio/exceptions.h>
#include <morphio/mut/endoplasmic_reticulum.h>
#include <morphio/mut/mitochondria.h>
#include <morphio/mut/modifiers.h>
#include <morphio/mut/soma.h>
#include <morphio/properties.h>
#include <morphio/types.h>
 
namespace morphio {
namespace mut {
// TODO: not sure why this is here
bool _checkDuplicatePoint(const std::shared_ptr<Section>& parent,
                          const std::shared_ptr<Section>& current);
 
class Morphology
{
  public:
    Morphology()
        : _soma(std::make_shared<Soma>())
        , _cellProperties(
              std::make_shared<morphio::Property::CellLevel>(morphio::Property::CellLevel())) {}
 
    explicit Morphology(const std::string& uri, unsigned int options = NO_MODIFIER);
 
    Morphology(const morphio::mut::Morphology& morphology, unsigned int options = NO_MODIFIER);
 
    explicit Morphology(const morphio::Morphology& morphology, unsigned int options = NO_MODIFIER);
 
    virtual ~Morphology();
 
    inline const std::vector<std::shared_ptr<Section>>& rootSections() const noexcept;
 
    inline const std::map<uint32_t, std::shared_ptr<Section>>& sections() const noexcept;
 
    inline std::shared_ptr<Soma>& soma() noexcept;
 
    inline const std::shared_ptr<Soma>& soma() const noexcept;
 
    inline Mitochondria& mitochondria() noexcept;
    inline const Mitochondria& mitochondria() const noexcept;
 
    inline EndoplasmicReticulum& endoplasmicReticulum() noexcept;
    inline const EndoplasmicReticulum& endoplasmicReticulum() const noexcept;
 
    inline const std::vector<Property::Annotation>& annotations() const noexcept;
 
    inline const std::vector<Property::Marker>& markers() const noexcept;
 
    inline const std::shared_ptr<Section>& section(uint32_t id) const;
 
    depth_iterator depth_begin() const;
    depth_iterator depth_end() const;
 
    breadth_iterator breadth_begin() const;
    breadth_iterator breadth_end() const;
 
    //
    //   Tree manipulation methods
    //
 
    void deleteSection(std::shared_ptr<Section> section, bool recursive = true);
 
    std::shared_ptr<Section> appendRootSection(const morphio::Section&, bool recursive = false);
 
    std::shared_ptr<Section> appendRootSection(const std::shared_ptr<Section>& section,
                                               bool recursive = false);
 
    std::shared_ptr<Section> appendRootSection(const Property::PointLevel&,
                                               SectionType sectionType);
 
    void applyModifiers(unsigned int modifierFlags);
 
    inline SomaType somaType() const noexcept;
 
    inline CellFamily cellFamily() const noexcept;
 
    inline MorphologyVersion version() const noexcept;
 
    void write(const std::string& filename);
 
    inline void addAnnotation(const morphio::Property::Annotation& annotation);
    inline void addMarker(const morphio::Property::Marker& marker);
 
    Property::Properties buildReadOnly() const;
 
    std::unordered_map<int, std::vector<unsigned int>> connectivity();
 
    void removeUnifurcations();
    void removeUnifurcations(const morphio::readers::DebugInfo& debugInfo);
 
    void _raiseIfUnifurcations();
 
  public:
    friend class Section;
    friend void modifiers::nrn_order(morphio::mut::Morphology& morpho);
    friend bool diff(const Morphology& left,
                     const Morphology& right,
                     morphio::enums::LogLevel verbose);
    morphio::readers::ErrorMessages _err;
 
    uint32_t _register(const std::shared_ptr<Section>&);
 
    uint32_t _counter = 0;
    std::shared_ptr<Soma> _soma;
    std::shared_ptr<morphio::Property::CellLevel> _cellProperties;
    std::vector<std::shared_ptr<Section>> _rootSections;
    std::map<uint32_t, std::shared_ptr<Section>> _sections;
 
    Mitochondria _mitochondria;
    EndoplasmicReticulum _endoplasmicReticulum;
    morphio::Property::DendriticSpine::Level _dendriticSpineLevel;
 
    std::map<uint32_t, uint32_t> _parent;
    std::map<uint32_t, std::vector<std::shared_ptr<Section>>> _children;
 
  private:
    void eraseByValue(std::vector<std::shared_ptr<Section>>& vec,
                      const std::shared_ptr<Section> section);
};
 
inline const std::vector<std::shared_ptr<Section>>& Morphology::rootSections() const noexcept {
    return _rootSections;
}
 
inline const std::map<uint32_t, std::shared_ptr<Section>>& Morphology::sections() const noexcept {
    return _sections;
}
 
inline std::shared_ptr<Soma>& Morphology::soma() noexcept {
    return _soma;
}
 
inline const std::shared_ptr<Soma>& Morphology::soma() const noexcept {
    return _soma;
}
 
inline Mitochondria& Morphology::mitochondria() noexcept {
    return _mitochondria;
}
 
inline const Mitochondria& Morphology::mitochondria() const noexcept {
    return _mitochondria;
}
 
inline EndoplasmicReticulum& Morphology::endoplasmicReticulum() noexcept {
    return _endoplasmicReticulum;
}
 
inline const EndoplasmicReticulum& Morphology::endoplasmicReticulum() const noexcept {
    return _endoplasmicReticulum;
}
 
inline const std::shared_ptr<Section>& Morphology::section(uint32_t id) const {
    return _sections.at(id);
}
 
inline SomaType Morphology::somaType() const noexcept {
    return _soma->type();
}
 
inline const std::vector<Property::Annotation>& Morphology::annotations() const noexcept {
    return _cellProperties->_annotations;
}
 
inline const std::vector<Property::Marker>& Morphology::markers() const noexcept {
    return _cellProperties->_markers;
}
 
inline CellFamily Morphology::cellFamily() const noexcept {
    return _cellProperties->_cellFamily;
}
 
inline MorphologyVersion Morphology::version() const noexcept {
    return _cellProperties->_version;
}
 
inline void Morphology::addAnnotation(const morphio::Property::Annotation& annotation) {
    _cellProperties->_annotations.push_back(annotation);
}
 
inline void Morphology::addMarker(const morphio::Property::Marker& marker) {
    _cellProperties->_markers.push_back(marker);
}
 
}  // namespace mut
}  // namespace morphio