DepthStableRegionComputer.hpp

#pragma once
 
#include "../attributes/AttributeComputation.hpp"
#include "../trees/detail/TreeNeighborhood.hpp"
#include "../trees/MorphologicalTree.hpp"
#include "../utils/Common.hpp"
#include "../utils/Contract.hpp"
#include "detail/VariationMeasure.hpp"
 
#include <concepts>
#include <limits>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
template <std::floating_point Real = float> class DepthStableRegionComputer {
  public:
    using variation_value_type = Real;
 
  private:
    const MorphologicalTree& tree;
    const Real* externalAttr_ = nullptr;
    std::vector<Real> ownedAttr_;
    Real maxVariation = Real{10};
    Real minAttr = Real{0};
    Real maxAttr;
    int num = 0;
    bool hasComputed_ = false;
    std::vector<Real> variation;
    std::vector<NodeId> ancestors;
    std::vector<NodeId> descendants;
 
    [[nodiscard]] const Real* attributeData() const noexcept { return ownedAttr_.empty() ? externalAttr_ : ownedAttr_.data(); }
 
    void requireComputed(const char* context) const {
        MMCFILTERS_CONTRACT_REQUIRE(hasComputed_, throw std::logic_error(std::string(context) + " requires computeByDepth to run first."));
    }
 
    static void validateOwnedAttributeSize(const MorphologicalTree& tree, const std::vector<Real>& attr) {
        MMCFILTERS_CONTRACT_REQUIRE(attr.size() == static_cast<std::size_t>(tree.numInternalNodeSlots()),
                                    throw std::invalid_argument("DepthStableRegionComputer attribute size must match the internal node slot count."));
    }
 
    DepthStableRegionComputer(const MorphologicalTree& tree, const Real* attr, std::vector<Real> ownedAttr)
        : tree(tree), externalAttr_(attr), ownedAttr_(std::move(ownedAttr)),
          maxAttr(static_cast<Real>(tree.numColumns() * tree.numRows())) {}
 
  public:
    DepthStableRegionComputer(const MorphologicalTree& tree, std::vector<Real> attr)
        : DepthStableRegionComputer(tree, nullptr, [&]() {
              validateOwnedAttributeSize(tree, attr);
              return std::move(attr);
          }()) {}
 
    DepthStableRegionComputer(const MorphologicalTree& tree, const Real* attr) : DepthStableRegionComputer(tree, attr, {}) {
        MMCFILTERS_CONTRACT_REQUIRE(
            attr != nullptr,
            throw std::invalid_argument("DepthStableRegionComputer requires a non-null attribute buffer for the raw-pointer constructor."));
    }
 
    explicit DepthStableRegionComputer(const MorphologicalTree& tree) : DepthStableRegionComputer(tree, nullptr, {}) {}
 
    DepthStableRegionComputer(const DepthStableRegionComputer&) = default;
    DepthStableRegionComputer(DepthStableRegionComputer&&) noexcept = default;
    DepthStableRegionComputer& operator=(const DepthStableRegionComputer&) = delete;
    DepthStableRegionComputer& operator=(DepthStableRegionComputer&&) = delete;
 
    [[nodiscard]] std::vector<uint8_t> computeByDepth(int depthWindowRadius) {
        MMCFILTERS_CONTRACT_REQUIRE(depthWindowRadius > 0,
                                    throw std::invalid_argument("DepthStableRegionComputer requires a positive depth window radius."));
        detail::TreeNeighborhood neighborhood(this->tree);
        neighborhood.computeByDepth(depthWindowRadius);
        this->ancestors = std::move(neighborhood.ancestors);
        this->descendants = std::move(neighborhood.descendants);
 
        auto attrAt = [this](NodeId node) -> Real { return this->getAttribute(node); };
        this->variation = detail::computeVariationsFromNeighborhood<Real>(this->tree, this->ancestors, this->descendants, attrAt);
        std::vector<uint8_t> selected = detail::selectStrictVariationMinima<Real>(this->tree, this->variation, this->ancestors, this->descendants, attrAt,
                                                                                  this->maxVariation, this->minAttr, this->maxAttr, this->num);
        this->hasComputed_ = true;
        return selected;
    }
 
    [[nodiscard]] Real getVariation(NodeId node) {
        requireComputed("DepthStableRegionComputer::getVariation");
        detail::validateStabilityNeighborhoodShape(this->tree, this->ancestors, this->descendants, "DepthStableRegionComputer::getVariation");
        auto attrAt = [this](NodeId nodeId) -> Real { return this->getAttribute(nodeId); };
        return detail::computeVariationValue<Real>(node, this->ancestors, this->descendants, attrAt);
    }
 
    [[nodiscard]] Real getAttribute(NodeId node) {
        if (attributeData() == nullptr) {
            auto area = AttributeComputation::computeSingleTopologyAttribute<Real>(this->tree, Area);
            this->ownedAttr_ = std::move(area.second);
        }
        const Real* data = attributeData();
        if (data == nullptr) {
            throw std::logic_error("DepthStableRegionComputer attribute storage is unavailable.");
        }
        return data[static_cast<std::size_t>(node)];
    }
 
    [[nodiscard]] NodeId nodeWithMinimumVariationInWindow(NodeId node) const {
        requireComputed("DepthStableRegionComputer::nodeWithMinimumVariationInWindow");
        detail::validateStabilityNeighborhoodShape(this->tree, this->ancestors, this->descendants,
                                                   "DepthStableRegionComputer::nodeWithMinimumVariationInWindow");
        return detail::nodeWithMinimumVariationInWindow<Real>(node, this->variation, this->ancestors, this->descendants);
    }
 
    [[nodiscard]] NodeId ancestorInStabilityWindow(NodeId node) const {
        requireComputed("DepthStableRegionComputer::ancestorInStabilityWindow");
        return this->ancestors[static_cast<std::size_t>(node)];
    }
 
    [[nodiscard]] NodeId descendantInStabilityWindow(NodeId node) const {
        requireComputed("DepthStableRegionComputer::descendantInStabilityWindow");
        return this->descendants[static_cast<std::size_t>(node)];
    }
 
    [[nodiscard]] std::vector<Real>& getVariations() {
        requireComputed("DepthStableRegionComputer::getVariations");
        return variation;
    }
 
    [[nodiscard]] int numNodes() const {
        requireComputed("DepthStableRegionComputer::numNodes");
        return num;
    }
 
    void setMaxVariation(Real value) { this->maxVariation = value; }
 
    void setMinAttribute(Real value) { this->minAttr = value; }
 
    void setMaxAttribute(Real value) { this->maxAttr = value; }
};
 
} // namespace mmcfilters