MSERComputer.hpp

#pragma once
 
#include "../attributes/AttributeComputation.hpp"
#include "../trees/detail/TreeNeighborhood.hpp"
#include "../trees/MorphologicalTree.hpp"
#include "../trees/TreeAltitudeAlgorithms.hpp"
#include "../trees/ValuedMorphologicalTree.hpp"
#include "../utils/Common.hpp"
#include "../utils/Contract.hpp"
#include "detail/VariationMeasure.hpp"
 
#include <cassert>
#include <cmath>
#include <concepts>
#include <limits>
#include <memory>
#include <span>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
template <AltitudeValue T, std::floating_point Real = float> class MSERComputer {
  public:
    using variation_value_type = Real;
 
  private:
    const ValuedMorphologicalTree<T>& valuedTree_;
    const MorphologicalTree& tree;
    const std::vector<T>& altitude_;
    const Real* externalAttrMser_;
    std::vector<Real> ownedAttrMser_;
    Real maxVariation;
    Real minAttr;
    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 ownedAttrMser_.empty() ? externalAttrMser_ : ownedAttrMser_.data(); }
 
    void requireComputed(const char* context) const {
        MMCFILTERS_CONTRACT_REQUIRE(hasComputed_, throw std::logic_error(std::string(context) + " requires computeMSER 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("MSERComputer attribute size must match the internal node slot count."));
    }
 
    MSERComputer(const ValuedMorphologicalTree<T>& valuedTree, const Real* attr_increasing, std::vector<Real> ownedAttr)
        : valuedTree_(valuedTree), tree(valuedTree.topology()), altitude_(valuedTree.nodeAltitudes()), externalAttrMser_(attr_increasing),
          ownedAttrMser_(std::move(ownedAttr)), maxVariation(Real{10}), minAttr(Real{0}),
          maxAttr(static_cast<Real>(this->tree.numColumns() * this->tree.numRows())) {
        TreeAltitudeAlgorithms::validateNodeAltitudeBufferShape(this->tree, std::span<const T>(this->altitude_));
        TreeAltitudeAlgorithms::requireGlobalMonotoneAltitudeOrder(this->tree, "MSERComputer");
    }
 
  public:
    MSERComputer(const ValuedMorphologicalTree<T>& valuedTree, std::vector<Real> attr_increasing)
        : MSERComputer(valuedTree, nullptr, [&]() {
              validateOwnedAttributeSize(valuedTree.topology(), attr_increasing);
              return std::move(attr_increasing);
          }()) {}
 
    MSERComputer(const ValuedMorphologicalTree<T>& valuedTree, const Real* attr_increasing) : MSERComputer(valuedTree, attr_increasing, {}) {
        MMCFILTERS_CONTRACT_REQUIRE(
            attr_increasing != nullptr,
            throw std::invalid_argument("MSERComputer requires a non-null attribute buffer for the raw-pointer constructor."));
    }
 
    MSERComputer(const ValuedMorphologicalTree<T>& valuedTree) : MSERComputer(valuedTree, nullptr, {}) {}
 
    MSERComputer(const MSERComputer&) = default;
    MSERComputer(MSERComputer&&) noexcept = default;
    MSERComputer& operator=(const MSERComputer&) = delete;
    MSERComputer& operator=(MSERComputer&&) = delete;
 
    ~MSERComputer() = default;
 
    [[nodiscard]] std::vector<uint8_t> computeMSER(AltitudeDifference<T> altitudeWindowRadius) {
        if constexpr (std::is_floating_point_v<AltitudeDifference<T>>) {
            MMCFILTERS_CONTRACT_REQUIRE(std::isfinite(altitudeWindowRadius),
                                        throw std::invalid_argument("MSERComputer requires a finite altitude window radius."));
        }
        MMCFILTERS_CONTRACT_REQUIRE(altitudeWindowRadius > AltitudeDifference<T>{},
                                    throw std::invalid_argument("MSERComputer requires a positive altitude window radius."));
        detail::TreeNeighborhood neighborhood(tree);
        neighborhood.computeByAltitude(std::span<const T>(altitude_), altitudeWindowRadius);
        this->ancestors = std::move(neighborhood.ancestors);
        this->descendants = std::move(neighborhood.descendants);
 
        auto attrAt = [this](NodeId node) -> Real { return this->getAttrMSER(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("MSERComputer::getVariation");
        detail::validateStabilityNeighborhoodShape(this->tree, this->ancestors, this->descendants, "MSERComputer::getVariation");
        auto attrAt = [this](NodeId nodeId) -> Real { return this->getAttrMSER(nodeId); };
        return detail::computeVariationValue<Real>(node, this->ancestors, this->descendants, attrAt);
    }
 
    [[nodiscard]] Real getAttrMSER(NodeId node) {
        if (attributeData() == nullptr) {
            auto area = AttributeComputation::computeSingleAttribute<Real>(valuedTree_, Area);
            ownedAttrMser_ = std::move(area.second);
        }
        const Real* data = attributeData();
        if (data == nullptr) {
            throw std::logic_error("MSERComputer attribute storage is unavailable.");
        }
        return data[node];
    }
 
    [[nodiscard]] NodeId nodeWithMinimumVariationInWindow(NodeId node) {
        requireComputed("MSERComputer::nodeWithMinimumVariationInWindow");
        detail::validateStabilityNeighborhoodShape(this->tree, this->ancestors, this->descendants, "MSERComputer::nodeWithMinimumVariationInWindow");
        return detail::nodeWithMinimumVariationInWindow<Real>(node, this->variation, this->ancestors, this->descendants);
    }
 
    [[nodiscard]] NodeId ancestorInStabilityWindow(NodeId node) const {
        requireComputed("MSERComputer::ancestorInStabilityWindow");
        return this->ancestors[static_cast<std::size_t>(node)];
    }
 
    [[nodiscard]] NodeId descendantInStabilityWindow(NodeId node) const {
        requireComputed("MSERComputer::descendantInStabilityWindow");
        return this->descendants[node];
    }
 
    [[nodiscard]] std::vector<Real>& getVariations() {
        requireComputed("MSERComputer::getVariations");
        return this->variation;
    }
 
    [[nodiscard]] int numNodes() {
        requireComputed("MSERComputer::numNodes");
        return this->num;
    }
 
    void setMaxVariation(Real maxVariation) { this->maxVariation = maxVariation; }
    void setMinAttribute(Real minAttr) { this->minAttr = minAttr; }
    void setMaxAttribute(Real maxAttr) { this->maxAttr = maxAttr; }
};
 
} // namespace mmcfilters