morphology.h

#pragma once
 
#include <map>
#include <memory>
#include <string>
#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);
 
    explicit Morphology(const HighFive::Group& group, 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();
 
    const std::vector<std::shared_ptr<Section>>& rootSections() const noexcept {
        return _rootSections;
    }
 
    const std::map<uint32_t, std::shared_ptr<Section>>& sections() const noexcept {
        return _sections;
    }
 
    std::shared_ptr<Soma>& soma() noexcept {
        return _soma;
    }
 
    const std::shared_ptr<Soma>& soma() const noexcept {
        return _soma;
    }
 
    Mitochondria& mitochondria() noexcept {
        return _mitochondria;
    }
 
    const Mitochondria& mitochondria() const noexcept {
        return _mitochondria;
    }
 
    EndoplasmicReticulum& endoplasmicReticulum() noexcept {
        return _endoplasmicReticulum;
    }
    const EndoplasmicReticulum& endoplasmicReticulum() const noexcept {
        return _endoplasmicReticulum;
    }
 
    const std::vector<Property::Annotation>& annotations() const noexcept {
        return _cellProperties->_annotations;
    }
 
    const std::vector<Property::Marker>& markers() const noexcept {
        return _cellProperties->_markers;
    }
 
    const std::shared_ptr<Section>& section(uint32_t id) const {
        return _sections.at(id);
    }
 
    depth_iterator depth_begin() const;
    depth_iterator depth_end() const;
 
    breadth_iterator breadth_begin() const;
    breadth_iterator breadth_end() const;
 
    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);
 
    SomaType somaType() const noexcept {
        return _soma->type();
    }
 
    CellFamily cellFamily() const noexcept {
        return _cellProperties->_cellFamily;
    }
 
    MorphologyVersion version() const noexcept {
        return _cellProperties->_version;
    }
 
    void write(const std::string& filename) const;
 
    void addAnnotation(const morphio::Property::Annotation& annotation) {
        _cellProperties->_annotations.push_back(annotation);
    }
 
    void addMarker(const morphio::Property::Marker& marker) {
        _cellProperties->_markers.push_back(marker);
    }
 
    Property::Properties buildReadOnly() const;
 
    std::unordered_map<int, std::vector<unsigned int>> connectivity();
 
    void removeUnifurcations();
    void removeUnifurcations(const morphio::readers::DebugInfo& debugInfo);
 
    std::shared_ptr<Soma> _soma;
    std::shared_ptr<morphio::Property::CellLevel> _cellProperties;
    EndoplasmicReticulum _endoplasmicReticulum;
    morphio::Property::DendriticSpine::Level _dendriticSpineLevel;
 
  private:
    std::vector<std::shared_ptr<Section>> _rootSections;
    std::map<uint32_t, std::shared_ptr<Section>> _sections;
 
    Mitochondria _mitochondria;
 
    std::map<uint32_t, uint32_t> _parent;
    std::map<uint32_t, std::vector<std::shared_ptr<Section>>> _children;
 
    uint32_t _counter = 0;
 
    uint32_t _register(const std::shared_ptr<Section>&);
    morphio::readers::ErrorMessages _err;
 
    void eraseByValue(std::vector<std::shared_ptr<Section>>& vec,
                      const std::shared_ptr<Section> section);
 
    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);
};
 
}  // namespace mut
}  // namespace morphio