morphology.h

#pragma once

#include <cstdint>
#include <iomanip>
#include <iostream>
#include <memory>
#include <ostream>
#include <unordered_map>

#include <functional>

#include <morphio/errorMessages.h>
#include <morphio/exceptions.h>
#include <morphio/mut/endoplasmic_reticulum.h>
#include <morphio/mut/mitochondria.h>
#include <morphio/mut/soma.h>
#include <morphio/properties.h>
#include <morphio/section.h>
#include <morphio/types.h>

namespace morphio {
namespace mut {
bool _checkDuplicatePoint(const std::shared_ptr<Section>& parent,
                          const std::shared_ptr<Section>& current);

class Morphology
{
  public:
    Morphology()
        : _counter(0)
        , _soma(std::make_shared<Soma>())
        , _cellProperties(
              std::make_shared<morphio::Property::CellLevel>(morphio::Property::CellLevel())) {}

    Morphology(const std::string& uri, unsigned int options = NO_MODIFIER);

    Morphology(const morphio::mut::Morphology& morphology, unsigned int options = NO_MODIFIER);

    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;
    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