DepthStableRegionComputer.hpp

#pragma once
 
#include "../attributes/AttributeComputation.hpp"
#include "../trees/detail/TreeStabilityNeighborhood.hpp"
#include "../trees/MorphologicalTree.hpp"
#include "../utils/Common.hpp"
#include "detail/VariationMeasure.hpp"
 
#include <concepts>
#include <limits>
#include <stdexcept>
#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* attrView_ = nullptr;
    std::vector<Real> ownedAttr_;
    Real maxVariation = Real{10};
    Real minAttr = Real{0};
    Real maxAttr;
    int num = 0;
    std::vector<Real> variation;
    std::vector<NodeId> ascendants;
    std::vector<NodeId> descendants;
 
    static void validateOwnedAttributeSize(const MorphologicalTree& tree, const std::vector<Real>& attr) {
        if (attr.size() != static_cast<std::size_t>(tree.getNumInternalNodeSlots())) {
            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),
          attrView_(nullptr),
          ownedAttr_(std::move(ownedAttr)),
          maxAttr(static_cast<Real>(tree.getNumColsOfImage() * tree.getNumRowsOfImage())) {
        this->attrView_ = this->ownedAttr_.empty() ? attr : this->ownedAttr_.data();
    }
 
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, {}) {
        if (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, {}) {}
 
    [[nodiscard]] std::vector<uint8_t> computeByDepth(int depthDelta) {
        detail::StabilityNeighborhood neighborhood =
            detail::computeDepthStabilityNeighborhood(this->tree, depthDelta);
        this->ascendants = std::move(neighborhood.ascendants);
        this->descendants = std::move(neighborhood.descendants);
 
        auto attrAt = [this](NodeId node) -> Real {
            return this->getAttribute(node);
        };
        this->variation =
            detail::computeVariationsFromNeighborhood<Real>(
                this->tree,
                this->ascendants,
                this->descendants,
                attrAt);
        return detail::selectStrictVariationMinima<Real>(
            this->tree,
            this->variation,
            this->ascendants,
            this->descendants,
            attrAt,
            this->maxVariation,
            this->minAttr,
            this->maxAttr,
            this->num);
    }
 
    [[nodiscard]] Real getVariation(NodeId node) {
        detail::validateStabilityNeighborhoodShape(
            this->tree,
            this->ascendants,
            this->descendants,
            "DepthStableRegionComputer::getVariation");
        if (this->variation.size() != static_cast<std::size_t>(this->tree.getNumInternalNodeSlots())) {
            throw std::logic_error("DepthStableRegionComputer::getVariation requires computeByDepth to run first.");
        }
        auto attrAt = [this](NodeId nodeId) -> Real {
            return this->getAttribute(nodeId);
        };
        return detail::computeVariationValue<Real>(
            node,
            this->ascendants,
            this->descendants,
            attrAt);
    }
 
    [[nodiscard]] Real getAttribute(NodeId node) {
        if (this->attrView_ == nullptr) {
            auto area = AttributeComputation::computeSingleTopologyAttribute<Real>(this->tree, AREA);
            this->ownedAttr_ = std::move(area.second);
            this->attrView_ = this->ownedAttr_.data();
        }
        return this->attrView_[static_cast<std::size_t>(node)];
    }
 
    [[nodiscard]] NodeId nodeWithMinimumVariationInWindow(NodeId node) const {
        detail::validateStabilityNeighborhoodShape(
            this->tree,
            this->ascendants,
            this->descendants,
            "DepthStableRegionComputer::nodeWithMinimumVariationInWindow");
        if (this->variation.size() != static_cast<std::size_t>(this->tree.getNumInternalNodeSlots())) {
            throw std::logic_error("DepthStableRegionComputer::nodeWithMinimumVariationInWindow requires computeByDepth to run first.");
        }
        return detail::nodeWithMinimumVariationInWindow<Real>(
            node,
            this->variation,
            this->ascendants,
            this->descendants);
    }
 
    [[nodiscard]] NodeId ascendantInStabilityWindow(NodeId node) const { return this->ascendants[static_cast<std::size_t>(node)]; }
 
    [[nodiscard]] NodeId descendantInStabilityWindow(NodeId node) const { return this->descendants[static_cast<std::size_t>(node)]; }
 
    std::vector<Real>& getVariations() { return variation; }
 
    [[nodiscard]] int getNumNodes() const { 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