WeightedMorphologicalTree.hpp

#pragma once
 
#include "MorphologicalTree.hpp"
#include "TreeAltitudeAlgorithms.hpp"
#include "TreeEditor.hpp"
#include "WeightedTreeView.hpp"
 
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
template<AltitudeValue T>
class WeightedTreeEditor;
 
template<AltitudeValue T>
class WeightedMorphologicalTree;
 
 
namespace detail {
 
enum class AltitudeDomain {
    InternalNodeSlots,
 
    HigraNodeIds
};
 
template<AltitudeValue T>
struct AltitudeInput {
    std::span<const T> values;
    AltitudeDomain domain;
};
 
} // namespace detail
 
template<AltitudeValue T>
class WeightedMorphologicalTree {
    friend class WeightedTreeEditor<T>;
 
public:
    using altitude_type = T;
 
    using altitude_buffer = std::vector<T>;
 
private:
    MorphologicalTree tree_;
    altitude_buffer altitude_;
 
    void assignAltitudeFromDirectProperParts(const ImagePtr<T>& img) {
        altitude_.assign(static_cast<size_t>(tree_.getNumInternalNodeSlots()), T{});
        for (NodeId nodeId : tree_.getAliveNodeIds()) {
            const auto properParts = tree_.getProperParts(nodeId);
            auto it = properParts.begin();
            if (it == properParts.end()) {
                throw std::runtime_error("Cannot infer node altitude from a topology node without direct proper parts.");
            }
            altitude_[static_cast<size_t>(nodeId)] = static_cast<T>((*img)[*it]);
        }
    }
 
    void assignInternalAltitude(std::span<const T> altitudeValues) {
        if (altitudeValues.size() != static_cast<size_t>(tree_.getNumInternalNodeSlots())) {
            throw std::invalid_argument("Internal altitude buffer size must match the dense internal-node domain.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValues(altitudeValues, "WeightedMorphologicalTree internal altitude input");
        altitude_.assign(altitudeValues.begin(), altitudeValues.end());
    }
 
    void importAltitudeFromHigra(std::span<const T> higraAltitude) {
        if (static_cast<size_t>(tree_.getNumHigraNodes()) != higraAltitude.size()) {
            throw std::invalid_argument("Higra altitude buffer size must match the preserved imported Higra hierarchy.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValues(higraAltitude, "WeightedMorphologicalTree Higra altitude input");
        altitude_.assign(static_cast<size_t>(tree_.getNumInternalNodeSlots()), T{});
        for (NodeId slotId = 0; slotId < tree_.getNumInternalNodeSlots(); ++slotId) {
            const NodeId higraNodeId = tree_.getHigraNodeId(slotId);
            altitude_[static_cast<size_t>(slotId)] = static_cast<T>(higraAltitude[static_cast<size_t>(higraNodeId)]);
        }
    }
 
    static bool skipsMonotoneValidation(const MorphologicalTree& tree) noexcept {
        const MorphologicalTreeKind treeType = tree.getTreeType();
        return treeType == MorphologicalTreeKind::TREE_OF_SHAPES || treeType == MorphologicalTreeKind::SELF_DUAL_RESIDUAL_TREE;
    }
 
    void validateLocalMonotoneAltitudeUpdate(NodeId nodeId, T value) const {
        if (skipsMonotoneValidation(tree_)) {
            return;
        }
 
        const bool increasingTowardLeaves = tree_.getTreeType() == MorphologicalTreeKind::MAX_TREE;
        if (!tree_.isRoot(nodeId)) {
            const NodeId parentNodeId = tree_.getNodeParent(nodeId);
            if (parentNodeId == InvalidNode || !tree_.isAlive(parentNodeId)) {
                throw std::runtime_error("Monotone altitude update requires an alive non-root node to have an alive parent.");
            }
            const T parentAltitude = altitude_[static_cast<size_t>(parentNodeId)];
            if (increasingTowardLeaves && parentAltitude > value) {
                throw std::runtime_error("Max-tree altitude update must keep altitude non-decreasing from parent to child.");
            }
            if (!increasingTowardLeaves && parentAltitude < value) {
                throw std::runtime_error("Min-tree altitude update must keep altitude non-increasing from parent to child.");
            }
        }
 
        for (NodeId childId : tree_.getChildren(nodeId)) {
            const T childAltitude = altitude_[static_cast<size_t>(childId)];
            if (increasingTowardLeaves && value > childAltitude) {
                throw std::runtime_error("Max-tree altitude update must keep altitude non-decreasing from parent to child.");
            }
            if (!increasingTowardLeaves && value < childAltitude) {
                throw std::runtime_error("Min-tree altitude update must keep altitude non-increasing from parent to child.");
            }
        }
    }
 
private:
    WeightedMorphologicalTree() = delete;
 
public:
    WeightedMorphologicalTree(const WeightedMorphologicalTree&) = delete;
    WeightedMorphologicalTree& operator=(const WeightedMorphologicalTree&) = delete;
 
    WeightedMorphologicalTree(WeightedMorphologicalTree&&) noexcept = default;
 
    WeightedMorphologicalTree& operator=(WeightedMorphologicalTree&&) noexcept = default;
 
    WeightedMorphologicalTree(detail::MorphologicalTreeConstructionTag, MorphologicalTree&& topology, ImagePtr<T> img) : tree_(std::move(topology)) {
        if (!img) {
            throw std::invalid_argument("WeightedMorphologicalTree construction requires a non-null image.");
        }
        if (img->getNumRows() <= 0 || img->getNumCols() <= 0 || img->getSize() <= 0) {
            throw std::invalid_argument("WeightedMorphologicalTree construction requires a non-empty 2D image.");
        }
 
        if (img->getNumRows() != tree_.getNumRowsOfImage() || img->getNumCols() != tree_.getNumColsOfImage() || img->getSize() != tree_.getNumTotalProperParts()) {
            throw std::invalid_argument("WeightedMorphologicalTree construction requires an image domain matching the topology.");
        }
 
        assignAltitudeFromDirectProperParts(img);
        validateAltitudeBufferShape();
    }
 
    WeightedMorphologicalTree(detail::MorphologicalTreeConstructionTag, MorphologicalTree&& topology, detail::AltitudeInput<T> altitude) : tree_(std::move(topology)) {
        switch (altitude.domain) {
            case detail::AltitudeDomain::InternalNodeSlots:
                assignInternalAltitude(altitude.values);
                break;
            case detail::AltitudeDomain::HigraNodeIds:
                importAltitudeFromHigra(altitude.values);
                break;
        }
        validateAltitudeBufferShape();
    }
 
    void validateAltitudeBufferShape() const {
        TreeAltitudeAlgorithms::validateAltitudeBufferShape(tree_, altitudeSpan());
    }
 
    [[nodiscard]] const MorphologicalTree& topology() const noexcept {
        return tree_;
    }
 
    [[nodiscard]] const altitude_buffer& getAltitudeBuffer() const noexcept {
        return altitude_;
    }
 
    [[nodiscard]] AltitudeSpan<T> altitudeSpan() const noexcept {
        return std::span<const T>(altitude_);
    }
 
    [[nodiscard]] WeightedTreeView<T> asView() const {
        return WeightedTreeView<T>(tree_, altitudeSpan());
    }
 
    void setAltitudeBuffer(altitude_buffer altitudeBuffer) {
        tree_.requireNotEditing("WeightedMorphologicalTree::setAltitudeBuffer");
        if (altitudeBuffer.size() != static_cast<size_t>(tree_.getNumInternalNodeSlots())) {
            throw std::runtime_error("Altitude buffer size must match the dense internal-node domain.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValues(std::span<const T>(altitudeBuffer), "WeightedMorphologicalTree::setAltitudeBuffer");
        TreeAltitudeAlgorithms::validateMonotoneAltitude(tree_, std::span<const T>(altitudeBuffer));
        altitude_ = std::move(altitudeBuffer);
    }
 
    void setAltitudeBufferUnchecked(altitude_buffer altitudeBuffer) {
        tree_.requireNotEditing("WeightedMorphologicalTree::setAltitudeBufferUnchecked");
        if (altitudeBuffer.size() != static_cast<size_t>(tree_.getNumInternalNodeSlots())) {
            throw std::runtime_error("Altitude buffer size must match the dense internal-node domain.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValues(std::span<const T>(altitudeBuffer), "WeightedMorphologicalTree::setAltitudeBufferUnchecked");
        altitude_ = std::move(altitudeBuffer);
    }
 
    void validateMonotoneAltitude() const {
        TreeAltitudeAlgorithms::validateMonotoneAltitude(tree_, altitudeSpan());
    }
 
    [[nodiscard]] T getAltitude(NodeId nodeId) const {
        if (!tree_.isAlive(nodeId) || static_cast<size_t>(nodeId) >= altitude_.size()) {
            throw std::invalid_argument("WeightedMorphologicalTree::getAltitude requires a live internal NodeId.");
        }
        return altitude_[static_cast<size_t>(nodeId)];
    }
 
    void setAltitude(NodeId nodeId, T value) {
        tree_.requireNotEditing("WeightedMorphologicalTree::setAltitude");
        if (!tree_.isAlive(nodeId) || static_cast<size_t>(nodeId) >= altitude_.size()) {
            throw std::invalid_argument("WeightedMorphologicalTree::setAltitude requires a live internal NodeId.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValue(value, static_cast<std::size_t>(nodeId), "WeightedMorphologicalTree::setAltitude");
        validateLocalMonotoneAltitudeUpdate(nodeId, value);
        altitude_[static_cast<size_t>(nodeId)] = value;
    }
 
    void setAltitudeUnchecked(NodeId nodeId, T value) {
        tree_.requireNotEditing("WeightedMorphologicalTree::setAltitudeUnchecked");
        if (!tree_.isAlive(nodeId) || static_cast<size_t>(nodeId) >= altitude_.size()) {
            throw std::invalid_argument("WeightedMorphologicalTree::setAltitudeUnchecked requires a live internal NodeId.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValue(value, static_cast<std::size_t>(nodeId), "WeightedMorphologicalTree::setAltitudeUnchecked");
        altitude_[static_cast<size_t>(nodeId)] = value;
    }
 
    void pruneNode(NodeId nodeId) {
        tree_.requireNotEditing("WeightedMorphologicalTree::pruneNode");
        tree_.pruneNode(nodeId);
    }
 
    void mergeNodeIntoParent(NodeId nodeId) {
        tree_.requireNotEditing("WeightedMorphologicalTree::mergeNodeIntoParent");
        tree_.mergeNodeIntoParent(nodeId);
    }
 
    [[nodiscard]] AltitudeDiff<T> getNodeResidue(NodeId nodeId) const {
        return TreeAltitudeAlgorithms::getNodeResidue(tree_, altitudeSpan(), nodeId);
    }
 
    [[nodiscard]] ImagePtr<T> reconstructionImage() const {
        return TreeAltitudeAlgorithms::reconstructImage(tree_, altitudeSpan(), "WeightedMorphologicalTree::reconstructImage");
    }
 
    [[nodiscard]] std::pair<std::vector<NodeId>, std::vector<T>> exportHigraHierarchy() const {
        return TreeAltitudeAlgorithms::exportHigraHierarchy(tree_, altitudeSpan());
    }
 
    [[nodiscard("Discarding the editor leaves the weighted tree edit session open")]] WeightedTreeEditor<T> edit() {
        return WeightedTreeEditor<T>(*this);
    }
};
 
template<AltitudeValue T>
class WeightedTreeEditor {
    friend class WeightedMorphologicalTree<T>;
 
private:
    WeightedMorphologicalTree<T>& weighted_;
    TreeEditor editor_;
 
    explicit WeightedTreeEditor(WeightedMorphologicalTree<T>& weighted) : weighted_(weighted), editor_(weighted.tree_.edit()) {}
 
public:
 
    [[nodiscard("Discarding a detached node id makes the staged edit impossible to complete safely")]] NodeId createDetachedNode(T altitude = T{}) {
        TreeAltitudeAlgorithms::validateFiniteAltitudeValue(altitude, 0, "WeightedTreeEditor::createDetachedNode");
        const std::size_t requiredAltitudeSize = static_cast<std::size_t>(weighted_.tree_.getNumInternalNodeSlots()) + (weighted_.tree_.getNumFreeNodeSlots() == 0 ? 1u : 0u);
        weighted_.altitude_.reserve(requiredAltitudeSize);
        const NodeId nodeId = editor_.createDetachedNode();
        weighted_.altitude_.resize(static_cast<size_t>(weighted_.tree_.getNumInternalNodeSlots()), T{});
        weighted_.altitude_[static_cast<size_t>(nodeId)] = altitude;
        return nodeId;
    }
 
    void setNodeAltitude(NodeId nodeId, T altitude) {
        if (!weighted_.tree_.isAlive(nodeId)) {
            throw std::invalid_argument("WeightedTreeEditor::setNodeAltitude requires a live node.");
        }
        TreeAltitudeAlgorithms::validateFiniteAltitudeValue(altitude, static_cast<std::size_t>(nodeId), "WeightedTreeEditor::setNodeAltitude");
        weighted_.altitude_[static_cast<size_t>(nodeId)] = altitude;
    }
 
    void detach(NodeId nodeId) {
        editor_.detach(nodeId);
    }
 
    void reparent(NodeId nodeId, NodeId newParentId) {
        editor_.reparent(nodeId, newParentId);
    }
 
    void attach(NodeId parentId, NodeId detachedNodeId) {
        editor_.attach(parentId, detachedNodeId);
    }
 
    void moveChildren(NodeId parentId, NodeId sourceId) {
        editor_.moveChildren(parentId, sourceId);
    }
 
    void moveProperPart(NodeId targetNodeId, NodeId sourceNodeId, NodeId properPartId) {
        editor_.moveProperPart(targetNodeId, sourceNodeId, properPartId);
    }
 
    void moveProperParts(NodeId targetNodeId, NodeId sourceNodeId) {
        editor_.moveProperParts(targetNodeId, sourceNodeId);
    }
 
    void removeChild(NodeId parentNodeId, NodeId childId, bool releaseNodeFlag) {
        editor_.removeChild(parentNodeId, childId, releaseNodeFlag);
    }
 
    void releaseNode(NodeId nodeId) {
        editor_.releaseNode(nodeId);
    }
 
    void setRoot(NodeId nodeId) {
        editor_.setRoot(nodeId);
    }
 
    void pruneNode(NodeId nodeId) {
        editor_.pruneNode(nodeId);
    }
 
    void mergeNodeIntoParent(NodeId nodeId) {
        editor_.mergeNodeIntoParent(nodeId);
    }
 
    [[nodiscard]] bool hasDetachedAliveNodes() const noexcept {
        return editor_.hasDetachedAliveNodes();
    }
 
    [[nodiscard]] TreeValidationResult validate() const noexcept {
        return editor_.validate();
    }
 
    [[nodiscard("Inspect the validation result or use commit() for exception-based failure handling")]] TreeValidationResult validateAndCommit() noexcept {
        TreeValidationResult result = editor_.validate();
        if (!result.ok) {
            return result;
        }
        try {
            weighted_.validateMonotoneAltitude();
        } catch (const std::exception& ex) {
            return {false, ex.what()};
        } catch (...) {
            return {false, "WeightedTreeEditor monotone-altitude validation failed with an unknown error."};
        }
        editor_.commitUnchecked();
        return result;
    }
 
    void commit() {
        TreeValidationResult result = validateAndCommit();
        if (!result.ok) {
            throw std::runtime_error(result.message);
        }
    }
 
    void commitUnchecked() noexcept {
        editor_.commitUnchecked();
    }
};
 
} // namespace mmcfilters