morphology.h

/* Copyright (c) 2013-2023, EPFL/Blue Brain Project
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#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/section.h>
#include <morphio/mut/soma.h>
#include <morphio/properties.h>
#include <morphio/types.h>
#include <morphio/warning_handling.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(std::shared_ptr<WarningHandler> warning_handler = nullptr)
        : _soma(std::make_shared<Soma>())
        , _cellProperties(std::make_shared<Property::CellLevel>())
        , _handler(warning_handler ? warning_handler : morphio::getWarningHandler()) {}
 
    explicit Morphology(const std::string& uri,
                        unsigned int options = NO_MODIFIER,
                        std::shared_ptr<WarningHandler> warning_handler = nullptr);
 
    explicit Morphology(const HighFive::Group& group,
                        unsigned int options = NO_MODIFIER,
                        std::shared_ptr<WarningHandler> warning_handler = nullptr);
 
    Morphology(const mut::Morphology& morphology,
               unsigned int options = NO_MODIFIER,
               std::shared_ptr<WarningHandler> warning_handler = nullptr);
 
    explicit Morphology(const morphio::Morphology& morphology,
                        unsigned int options = NO_MODIFIER,
                        std::shared_ptr<WarningHandler> warning_handler = nullptr);
 
    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 Property::Annotation& annotation) {
        _cellProperties->_annotations.push_back(annotation);
    }
 
    void addMarker(const Property::Marker& marker) {
        _cellProperties->_markers.push_back(marker);
    }
 
    Property::Properties buildReadOnly() const;
 
    std::unordered_map<int, std::vector<unsigned int>> connectivity();
 
    void removeUnifurcations();
 
    std::shared_ptr<WarningHandler> getWarningHandler() const {
        return _handler;
    }
 
    std::shared_ptr<Soma> _soma;
    std::shared_ptr<Property::CellLevel> _cellProperties;
    EndoplasmicReticulum _endoplasmicReticulum;
    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>&);
 
    void eraseByValue(std::vector<std::shared_ptr<Section>>& vec,
                      const std::shared_ptr<Section>& section);
 
    std::shared_ptr<WarningHandler> _handler;
    std::string _uri;
 
    friend class Section;
    friend void modifiers::nrn_order(mut::Morphology& morpho);
    friend bool diff(const Morphology& left, const Morphology& right, enums::LogLevel verbose);
};
 
}  // namespace mut
}  // namespace morphio