ValuedMorphologicalTreeView.hpp

#pragma once
 
#include "MorphologicalTree.hpp"
#include "TreeAltitudeAlgorithms.hpp"
#include "../utils/Altitude.hpp"
#include "../utils/Contract.hpp"
 
#include <cstddef>
#include <span>
#include <stdexcept>
 
namespace mmcfilters {
 
template <AltitudeValue T> class ValuedMorphologicalTree;
 
template <AltitudeValue T> class ValuedMorphologicalTreeView {
    friend class ValuedMorphologicalTree<T>;
 
  private:
    const MorphologicalTree* topology_ = nullptr;
    NodeAltitudeSpan<T> nodeAltitudes_;
    std::size_t topologyMutationVersion_ = 0;
 
    void validateNodeAltitudeBufferShape() const {
        MMCFILTERS_CONTRACT_REQUIRE(nodeAltitudes_.size() == static_cast<std::size_t>(topology_->numInternalNodeSlots()),
                                    throw std::runtime_error("ValuedMorphologicalTreeView altitude size must match the dense internal-node domain."));
    }
 
    explicit ValuedMorphologicalTreeView(const ValuedMorphologicalTree<T>& owner)
        : topology_(&owner.topology()), nodeAltitudes_(owner.nodeAltitudeSpan()), topologyMutationVersion_(owner.topology().getMutationVersion()) {}
 
  public:
    using AltitudeType = T;
 
    explicit ValuedMorphologicalTreeView(const MorphologicalTree& topology, NodeAltitudeSpan<T> altitude)
        : topology_(&topology), nodeAltitudes_(altitude), topologyMutationVersion_(topology.getMutationVersion()) {
        validateNodeAltitudeBufferShape();
        TreeAltitudeAlgorithms::validateFiniteAltitudeValues(altitude, "ValuedMorphologicalTreeView");
        TreeAltitudeAlgorithms::validateMonotoneNodeAltitudes(topology, altitude);
    }
 
    explicit ValuedMorphologicalTreeView(const MorphologicalTree& topology, const NodeAltitudeBuffer<T>& altitude)
        : ValuedMorphologicalTreeView(topology, std::span<const T>(altitude)) {}
 
    ValuedMorphologicalTreeView(const MorphologicalTree&, NodeAltitudeBuffer<T>&&) = delete;
 
    [[nodiscard]] const MorphologicalTree& topology() const noexcept { return *topology_; }
 
    [[nodiscard]] NodeAltitudeSpan<T> nodeAltitudes() const noexcept { return nodeAltitudes_; }
 
    void requireTopologyUnchanged(const char* context) const { topology().requireMutationVersion(topologyMutationVersion_, context); }
 
    [[nodiscard]] T nodeAltitude(NodeId nodeId) const {
        MMCFILTERS_CONTRACT_REQUIRE(nodeId >= 0 && static_cast<std::size_t>(nodeId) < nodeAltitudes_.size(),
                                    throw std::invalid_argument("ValuedMorphologicalTreeView::nodeAltitude requires a valid internal NodeId."));
        return nodeAltitudes_[static_cast<std::size_t>(nodeId)];
    }
 
    [[nodiscard]] AltitudeDifference<T> nodeResidue(NodeId nodeId) const {
        const MorphologicalTree& tree = topology();
        MMCFILTERS_CONTRACT_REQUIRE(tree.isAlive(nodeId), throw std::invalid_argument("ValuedMorphologicalTreeView::nodeResidue requires a live internal NodeId."));
        const NodeId parentNodeId = tree.parent(nodeId);
        if (parentNodeId == InvalidNode || parentNodeId == nodeId) {
            return static_cast<AltitudeDifference<T>>(nodeAltitude(nodeId));
        }
        return static_cast<AltitudeDifference<T>>(nodeAltitude(nodeId)) - static_cast<AltitudeDifference<T>>(nodeAltitude(parentNodeId));
    }
};
 
} // namespace mmcfilters