MSERComputer.hpp

#pragma once
 
#include "../attributes/AttributeComputation.hpp"
#include "../trees/detail/TreeStabilityNeighborhood.hpp"
#include "../trees/detail/TreeKindValidation.hpp"
#include "../trees/MorphologicalTree.hpp"
#include "../trees/TreeAltitudeAlgorithms.hpp"
#include "../trees/WeightedMorphologicalTree.hpp"
#include "../utils/Common.hpp"
#include "detail/VariationMeasure.hpp"
 
#include <cassert>
#include <cmath>
#include <concepts>
#include <limits>
#include <memory>
#include <span>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
template<AltitudeValue T, std::floating_point Real = float>
class MSERComputer {
public:
    using variation_value_type = Real;
 
private:
    const WeightedMorphologicalTree<T>& weighted_;
    const MorphologicalTree& tree;
    const std::vector<T>& altitude_;
    const Real* attrMserView_;
    std::vector<Real> ownedAttrMser_;
    Real maxVariation;
    Real minAttr;
    Real maxAttr;
    int num;
    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("MSERComputer attribute size must match the internal node slot count.");
        }
    }
 
    MSERComputer(const WeightedMorphologicalTree<T>& weighted, const Real* attr_increasing, std::vector<Real> ownedAttr)
        : weighted_(weighted),
          tree(weighted.topology()),
          altitude_(weighted.getAltitudeBuffer()),
          attrMserView_(nullptr),
          ownedAttrMser_(std::move(ownedAttr)),
          maxVariation(Real{10}),
          minAttr(Real{0}),
          maxAttr(static_cast<Real>(this->tree.getNumColsOfImage() * this->tree.getNumRowsOfImage())) {
        TreeAltitudeAlgorithms::validateAltitudeBufferShape(this->tree, std::span<const T>(this->altitude_));
        detail::validateComponentTreeKind(this->tree, "MSERComputer");
        this->attrMserView_ = this->ownedAttrMser_.empty() ? attr_increasing : this->ownedAttrMser_.data();
    }
 
public:
    MSERComputer(const WeightedMorphologicalTree<T>& weighted, std::vector<Real> attr_increasing)
        : MSERComputer(weighted, nullptr, [&]() {
            validateOwnedAttributeSize(weighted.topology(), attr_increasing);
            return std::move(attr_increasing);
        }()) {}
 
    MSERComputer(const WeightedMorphologicalTree<T>& weighted, const Real* attr_increasing)
        : MSERComputer(weighted, attr_increasing, {}) {
        if (attr_increasing == nullptr) {
            throw std::invalid_argument("MSERComputer requires a non-null attribute buffer for the raw-pointer constructor.");
        }
    }
 
    MSERComputer(const WeightedMorphologicalTree<T>& weighted)
        : MSERComputer(weighted, nullptr, {}) { }
 
    ~MSERComputer() = default;
 
    [[nodiscard]] std::vector<uint8_t> computeMSER(AltitudeDiff<T> delta){
        detail::StabilityNeighborhood neighborhood =
            detail::computeAltitudeStabilityNeighborhood(
                tree,
                std::span<const T>(altitude_),
                delta);
        this->ascendants = std::move(neighborhood.ascendants);
        this->descendants = std::move(neighborhood.descendants);
 
        auto attrAt = [this](NodeId node) -> Real {
            return this->getAttrMSER(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,
            "MSERComputer::getVariation");
        if (this->variation.size() != static_cast<std::size_t>(this->tree.getNumInternalNodeSlots())) {
            throw std::logic_error("MSERComputer::getVariation requires computeMSER to run first.");
        }
        auto attrAt = [this](NodeId nodeId) -> Real {
            return this->getAttrMSER(nodeId);
        };
        return detail::computeVariationValue<Real>(
            node,
            this->ascendants,
            this->descendants,
            attrAt);
    }
 
    [[nodiscard]] Real getAttrMSER(NodeId node){
        if(attrMserView_ == nullptr) {
            auto area = AttributeComputation::computeSingleAttribute<Real>(weighted_, AREA);
            ownedAttrMser_ = std::move(area.second);
            attrMserView_ = ownedAttrMser_.data();
        }
        if(attrMserView_ == nullptr)
            return Real{0};
        else
            return this->attrMserView_[node];
    }
 
    [[nodiscard]] NodeId nodeWithMinimumVariationInWindow(NodeId node){
        detail::validateStabilityNeighborhoodShape(
            this->tree,
            this->ascendants,
            this->descendants,
            "MSERComputer::nodeWithMinimumVariationInWindow");
        if (this->variation.size() != static_cast<std::size_t>(this->tree.getNumInternalNodeSlots())) {
            throw std::logic_error("MSERComputer::nodeWithMinimumVariationInWindow requires computeMSER to run first.");
        }
        return detail::nodeWithMinimumVariationInWindow<Real>(
            node,
            this->variation,
            this->ascendants,
            this->descendants);
    }
 
    [[nodiscard]] NodeId ascendantInStabilityWindow(NodeId node) const { return this->ascendants[node];}
    [[nodiscard]] NodeId descendantInStabilityWindow(NodeId node) const { return descendants[node];}
    std::vector<Real>& getVariations() { return variation; }
    [[nodiscard]] int getNumNodes() {return  num;}
    void setMaxVariation(Real maxVariation) { this->maxVariation = maxVariation; }
    void setMinAttribute(Real minAttr) { this->minAttr = minAttr; }
    void setMaxAttribute(Real maxAttr) { this->maxAttr = maxAttr; }
};
 
 
} // namespace mmcfilters