WeightedTreeView.hpp

#pragma once
 
#include "MorphologicalTree.hpp"
#include "../utils/Altitude.hpp"
 
#include <cstddef>
#include <span>
#include <stdexcept>
 
namespace mmcfilters {
 
template<AltitudeValue T>
class WeightedTreeView {
private:
    const MorphologicalTree* topology_ = nullptr;
    AltitudeSpan<T> altitude_;
    std::size_t topologyMutationVersion_ = 0;
 
    void validateAltitudeBufferShape() const {
        if (altitude_.size() != static_cast<std::size_t>(topology_->getNumInternalNodeSlots())) {
            throw std::runtime_error("WeightedTreeView altitude size must match the dense internal-node domain.");
        }
    }
 
public:
    using altitude_type = T;
 
    explicit WeightedTreeView(const MorphologicalTree& topology, AltitudeSpan<T> altitude)
        : topology_(&topology), altitude_(altitude), topologyMutationVersion_(topology.getMutationVersion()) {
        validateAltitudeBufferShape();
    }
 
    explicit WeightedTreeView(const MorphologicalTree& topology, const AltitudeBuffer<T>& altitude)
        : topology_(&topology), altitude_(std::span<const T>(altitude)), topologyMutationVersion_(topology.getMutationVersion()) {
        validateAltitudeBufferShape();
    }
 
    WeightedTreeView(const MorphologicalTree&, AltitudeBuffer<T>&&) = delete;
 
    [[nodiscard]] const MorphologicalTree& topology() const noexcept {
        return *topology_;
    }
 
    [[nodiscard]] AltitudeSpan<T> altitude() const noexcept {
        return altitude_;
    }
 
    void requireTopologyUnchanged(const char* context) const {
        topology().requireMutationVersion(topologyMutationVersion_, context);
    }
 
    [[nodiscard]] T getAltitude(NodeId nodeId) const {
        if (nodeId < 0 || static_cast<std::size_t>(nodeId) >= altitude_.size()) {
            throw std::invalid_argument("WeightedTreeView::getAltitude requires a valid internal NodeId.");
        }
        return altitude_[static_cast<std::size_t>(nodeId)];
    }
 
    [[nodiscard]] AltitudeDiff<T> getNodeResidue(NodeId nodeId) const {
        const MorphologicalTree& tree = topology();
        if (!tree.isAlive(nodeId)) {
            throw std::invalid_argument("WeightedTreeView::getNodeResidue requires a live internal NodeId.");
        }
        const NodeId parentNodeId = tree.getNodeParent(nodeId);
        if (parentNodeId == InvalidNode || parentNodeId == nodeId) {
            return static_cast<AltitudeDiff<T>>(getAltitude(nodeId));
        }
        return static_cast<AltitudeDiff<T>>(getAltitude(nodeId)) -
               static_cast<AltitudeDiff<T>>(getAltitude(parentNodeId));
    }
};
 
} // namespace mmcfilters