UltimateAttributeOpening.hpp

#pragma once
 
#include "../utils/Image.hpp"
#include "../utils/Common.hpp"
#include "../trees/WeightedMorphologicalTree.hpp"
#include "../trees/WeightedTreeView.hpp"
#include "DepthStableRegionComputer.hpp"
#include "MSERComputer.hpp"
 
#include <cmath>
#include <concepts>
#include <memory>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace mmcfilters {
 
template<AltitudeValue T, std::floating_point Real = float>
class UltimateAttributeOpening {
public:
    using attribute_value_type = Real;
 
protected:
    using AltitudeView = WeightedTreeView<T>;
 
    Real maxCriterion = Real{0};
    const Real* const attrs_increasing;
    std::shared_ptr<Real[]> ownedAttrsIncreasing_;
    const WeightedMorphologicalTree<T>* weighted_ = nullptr;
    AltitudeView view_;
    const MorphologicalTree& tree;
    std::size_t treeMutationVersion_ = 0;
    std::vector<T> maxContrastLUT;
    std::vector<int> associatedIndexLUT;
    std::vector<uint8_t> selectedForFiltering;
 
    AltitudeView view() const {
        return weighted_ != nullptr ? weighted_->asView() : view_;
    }
 
    void requireStableTree(const char* context) const {
        tree.requireMutationVersion(treeMutationVersion_, context);
    }
 
    static T altitudeOf(const AltitudeView& view, NodeId nodeId) {
        return view.getAltitude(nodeId);
    }
 
    static void requireAttributePointer(const Real* attr, const char* context) {
        if (attr == nullptr) {
            throw std::invalid_argument(std::string(context) + " requires a non-null attribute buffer.");
        }
    }
 
    static const Real* requireAttributeBuffer(const MorphologicalTree& tree, const std::vector<Real>& attr, const char* context) {
        if (attr.size() != static_cast<std::size_t>(tree.getNumInternalNodeSlots())) {
            throw std::invalid_argument(std::string(context) + " attribute size must match the internal node slot count.");
        }
        return attr.data();
    }
 
    static T absoluteAltitudeDifference(AltitudeDiff<T> lhs, AltitudeDiff<T> rhs) {
        const long double difference = std::abs(static_cast<long double>(lhs) - static_cast<long double>(rhs));
        // UAO stores the contrast in the same type as the altitude by API
        // decision. For signed integral altitudes, contrasts that do not fit in
        // T can lose information here; avoiding that requires a separate
        // contrast type, which this API intentionally does not introduce.
        return static_cast<T>(difference);
    }
 
    void computeUAO(const AltitudeView& view, NodeId currentNodeId, AltitudeDiff<T> altitudeNodeNotInNR, bool qPropag, bool isCalculateResidue) {
        const NodeId parentNodeId = tree.getNodeParent(currentNodeId);
        const AltitudeDiff<T> altitudeNodeInNR = static_cast<AltitudeDiff<T>>(altitudeOf(view, currentNodeId));
        bool flagPropag = false;
        T contrast = T{};
 
        if (this->isSelectedForPruning(currentNodeId)) {
            altitudeNodeNotInNR = static_cast<AltitudeDiff<T>>(altitudeOf(view, parentNodeId));
            if (this->attrs_increasing[currentNodeId] <= this->maxCriterion) {
                isCalculateResidue = hasNodeSelectedInPrimitive(currentNodeId);
            }
        }
 
        if (this->attrs_increasing[currentNodeId] <= this->maxCriterion) {
            if (isCalculateResidue) {
                contrast = absoluteAltitudeDifference(altitudeNodeInNR, altitudeNodeNotInNR);
            }
 
            if (this->maxContrastLUT[parentNodeId] >= contrast) {
                this->maxContrastLUT[currentNodeId] = this->maxContrastLUT[parentNodeId];
                this->associatedIndexLUT[currentNodeId] = this->associatedIndexLUT[parentNodeId];
            } else {
                this->maxContrastLUT[currentNodeId] = contrast;
                this->associatedIndexLUT[currentNodeId] = !qPropag
                    ? static_cast<int>(this->attrs_increasing[currentNodeId] + 1)
                    : this->associatedIndexLUT[parentNodeId];
                flagPropag = true;
            }
        }
 
        for (NodeId childNodeId : tree.getChildren(currentNodeId)) {
            this->computeUAO(view, childNodeId, altitudeNodeNotInNR, flagPropag, isCalculateResidue);
        }
    }
 
    void executeImpl(Real maxCriterion, const std::vector<uint8_t>& selectedForFiltering) {
        const AltitudeView altitudeView = view();
        this->maxCriterion = maxCriterion;
        this->selectedForFiltering = selectedForFiltering;
 
        for (NodeId id : tree.getAliveNodeIds()) {
            maxContrastLUT[id] = T{};
            associatedIndexLUT[id] = 0;
        }
 
        const NodeId rootNodeId = tree.getRoot();
        const AltitudeDiff<T> level = static_cast<AltitudeDiff<T>>(altitudeOf(altitudeView, rootNodeId));
        for (NodeId childNodeId : tree.getChildren(rootNodeId)) {
            computeUAO(altitudeView, childNodeId, level, false, false);
        }
    }
 
    bool isSelectedForPruning(NodeId currentNodeId) const {
        const NodeId parentNodeId = tree.getNodeParent(currentNodeId);
        if (parentNodeId == InvalidNode) {
            return false;
        }
        return this->attrs_increasing[currentNodeId] != this->attrs_increasing[parentNodeId];
    }
 
    bool hasNodeSelectedInPrimitive(NodeId currentNodeId) const {
        std::stack<NodeId> stack;
        stack.push(currentNodeId);
        while (!stack.empty()) {
            const NodeId nodeId = stack.top();
            stack.pop();
            if (selectedForFiltering[nodeId]) {
                return true;
            }
 
            for (NodeId childNodeId : tree.getChildren(nodeId)) {
                if (this->attrs_increasing[childNodeId] == this->attrs_increasing[nodeId]) {
                    stack.push(childNodeId);
                }
            }
        }
        return false;
    }
 
public:
 
    UltimateAttributeOpening(const AltitudeView& view, const std::shared_ptr<Real[]>& attrs_increasing)
        : UltimateAttributeOpening(view, attrs_increasing.get()) {
        this->ownedAttrsIncreasing_ = attrs_increasing;
    }
 
    UltimateAttributeOpening(const AltitudeView& view, const std::vector<Real>& attrs_increasing)
        : UltimateAttributeOpening(view, requireAttributeBuffer(view.topology(), attrs_increasing, "UltimateAttributeOpening")) {}
 
    UltimateAttributeOpening(const AltitudeView& view, const Real* attrs_increasing)
        : attrs_increasing(attrs_increasing),
          view_(view),
          tree(view_.topology()),
          treeMutationVersion_(tree.getMutationVersion()),
          maxContrastLUT(this->tree.getNumInternalNodeSlots()),
          associatedIndexLUT(this->tree.getNumInternalNodeSlots()) {
        view_.requireTopologyUnchanged("UltimateAttributeOpening");
        requireAttributePointer(attrs_increasing, "UltimateAttributeOpening");
        this->selectedForFiltering.assign(this->tree.getNumInternalNodeSlots(), true);
    }
 
    UltimateAttributeOpening(const WeightedMorphologicalTree<T>& weighted, const std::shared_ptr<Real[]>& attrs_increasing)
        : UltimateAttributeOpening(weighted, attrs_increasing.get()) {
        this->ownedAttrsIncreasing_ = attrs_increasing;
    }
 
    UltimateAttributeOpening(const WeightedMorphologicalTree<T>& weighted, const std::vector<Real>& attrs_increasing)
        : UltimateAttributeOpening(weighted.asView(), attrs_increasing) {
        weighted_ = &weighted;
    }
 
    UltimateAttributeOpening(const WeightedMorphologicalTree<T>& weighted, const Real* attrs_increasing)
        : UltimateAttributeOpening(weighted.asView(), attrs_increasing) {
        weighted_ = &weighted;
    }
 
    ~UltimateAttributeOpening() = default;
 
public:
    void execute(Real maxCriterion) {
        requireStableTree("UltimateAttributeOpening::execute");
        std::vector<uint8_t> tmp(this->tree.getNumInternalNodeSlots(), true);
        executeImpl(maxCriterion, tmp);
    }
 
    void execute(Real maxCriterion, const std::vector<uint8_t>& selectedForFiltering) {
        requireStableTree("UltimateAttributeOpening::execute");
        if (selectedForFiltering.size() != static_cast<std::size_t>(this->tree.getNumInternalNodeSlots())) {
            throw std::invalid_argument("UltimateAttributeOpening::execute selectedForFiltering size must match the internal node slot count.");
        }
        executeImpl(maxCriterion, selectedForFiltering);
    }
 
    void executeWithMSER(Real maxCriterion, AltitudeDiff<T> deltaMSER)
    {
        requireStableTree("UltimateAttributeOpening::executeWithMSER");
        if (weighted_ == nullptr) {
            throw std::logic_error("UltimateAttributeOpening::executeWithMSER requires a WeightedMorphologicalTree owner because MSER uses the tree-owned altitude.");
        }
        MSERComputer<T, Real> mser(*weighted_);
        executeImpl(maxCriterion, mser.computeMSER(deltaMSER));
    }
 
    void executeWithDepthStability(Real maxCriterion, int depthDelta)
    {
        requireStableTree("UltimateAttributeOpening::executeWithDepthStability");
        DepthStableRegionComputer<Real> stabilityComputer(this->tree);
        executeImpl(maxCriterion, stabilityComputer.computeByDepth(depthDelta));
    }
 
    [[nodiscard]] ImagePtr<T> getMaxContrastImage() const {
        requireStableTree("UltimateAttributeOpening::getMaxContrastImage");
        const int size = this->tree.getNumColsOfImage() * this->tree.getNumRowsOfImage();
        ImagePtr<T> imgOut = Image<T>::create(this->tree.getNumRowsOfImage(), this->tree.getNumColsOfImage());
        auto out = imgOut->rawData();
 
        for (int pidx = 0; pidx < size; pidx++) {
            out[pidx] = this->maxContrastLUT[tree.getProperPartOwner(pidx)];
        }
        return imgOut;
    }
 
    [[nodiscard]] ImageInt32Ptr getAssociatedImage() const {
        requireStableTree("UltimateAttributeOpening::getAssociatedImage");
        const int size = this->tree.getNumColsOfImage() * this->tree.getNumRowsOfImage();
        ImageInt32Ptr imgOut = ImageInt32::create(this->tree.getNumRowsOfImage(), this->tree.getNumColsOfImage());
        auto out = imgOut->rawData();
 
        for (int pidx = 0; pidx < size; pidx++) {
            out[pidx] = this->associatedIndexLUT[tree.getProperPartOwner(pidx)];
        }
        return imgOut;
    }
 
    [[nodiscard]] ImageUInt8Ptr getAssociatedColorImage() const {
        requireStableTree("UltimateAttributeOpening::getAssociatedColorImage");
        return ImageUtils::createRandomColor(this->getAssociatedImage()->rawData(), this->tree.getNumRowsOfImage(), this->tree.getNumColsOfImage());
    }
};
 
 
} // namespace mmcfilters