ConnectedSubsetTreeLocalizer.hpp

#pragma once
 
#include "../trees/MorphologicalTree.hpp"
#include "../trees/detail/CommittedTreeAccess.hpp"
#include "../utils/Common.hpp"
 
#include <cstddef>
#include <optional>
#include <stdexcept>
 
namespace mmcfilters::local_attributes {
 
struct WindowOffset {
    int rowOffset = 0;    
    int columnOffset = 0; 
 
    friend bool operator==(const WindowOffset& lhs, const WindowOffset& rhs) = default;
};
 
namespace detail::kernel {
 
inline NodeId connectedSubsetJoin(const MorphologicalTree& tree, NodeId lhsSmallestNode, NodeId rhsSmallestNode) {
    return ::mmcfilters::detail::CommittedTreeAccess::lowestCommonAncestor(tree, lhsSmallestNode, rhsSmallestNode);
}
 
inline NodeId anchoredEntryFromSmallestNodes(const MorphologicalTree& tree, NodeId anchorSmallestNode, NodeId sampleSmallestNode) {
    return connectedSubsetJoin(tree, anchorSmallestNode, sampleSmallestNode);
}
 
inline NodeId anchoredEntry(const MorphologicalTree& tree, PixelId anchorPixel, PixelId samplePixel) {
    const NodeId anchorSmallestNode = ::mmcfilters::detail::CommittedTreeAccess::smallestNodeMap(tree, anchorPixel);
    const NodeId sampleSmallestNode = ::mmcfilters::detail::CommittedTreeAccess::smallestNodeMap(tree, samplePixel);
    return connectedSubsetJoin(tree, anchorSmallestNode, sampleSmallestNode);
}
 
inline NodeId anchoredEntry(const MorphologicalTree& tree, PixelId anchorPixel, WindowOffset offset) {
    const GridDomain2D& domain = ::mmcfilters::detail::CommittedTreeAccess::gridDomain2D(tree);
    const int anchorRow = anchorPixel / domain.columns;
    const int anchorColumn = anchorPixel % domain.columns;
    const int sampleRow = anchorRow + offset.rowOffset;
    const int sampleColumn = anchorColumn + offset.columnOffset;
    if (sampleRow < 0 || sampleRow >= domain.rows || sampleColumn < 0 || sampleColumn >= domain.columns) {
        return InvalidNode;
    }
    return anchoredEntry(tree, anchorPixel, static_cast<PixelId>(sampleRow * domain.columns + sampleColumn));
}
 
} // namespace detail::kernel
 
class ConnectedSubsetTreeLocalizer {
  public:
    explicit ConnectedSubsetTreeLocalizer(const MorphologicalTree& tree) : tree_(tree), mutationVersion_(tree.getMutationVersion()) {
        tree_.requireNotEditing("ConnectedSubsetTreeLocalizer");
    }
 
    [[nodiscard]] NodeId smallestNode(PixelId pixel) const {
        requireStableTree();
        if (!tree_.isPixel(pixel)) {
            throw std::out_of_range("ConnectedSubsetTreeLocalizer::smallestNode received an invalid pixel.");
        }
        const NodeId value = tree_.smallestNode(pixel);
        if (!tree_.isAlive(value)) {
            throw std::logic_error("ConnectedSubsetTreeLocalizer::smallestNode found a pixel without a live smallest node.");
        }
        return value;
    }
 
    [[nodiscard]] NodeId join(NodeId lhsSmallestNode, NodeId rhsSmallestNode) const {
        requireStableTree();
        if (!tree_.isAlive(lhsSmallestNode) || !tree_.isAlive(rhsSmallestNode)) {
            throw std::invalid_argument("ConnectedSubsetTreeLocalizer::join requires two live nodes.");
        }
        return detail::kernel::connectedSubsetJoin(tree_, lhsSmallestNode, rhsSmallestNode);
    }
 
    [[nodiscard]] std::optional<NodeId> anchoredEntry(PixelId anchorPixel, PixelId samplePixel) const {
        requireStableTree();
        if (!tree_.isPixel(anchorPixel) || !tree_.isPixel(samplePixel)) {
            return std::nullopt;
        }
        return detail::kernel::anchoredEntry(tree_, anchorPixel, samplePixel);
    }
 
    [[nodiscard]] std::optional<NodeId> anchoredEntry(PixelId anchorPixel, WindowOffset offset) const {
        requireStableTree();
        const GridDomain2D& domain = tree_.requireGridDomain2D("ConnectedSubsetTreeLocalizer::anchoredEntry");
        if (anchorPixel < 0 || anchorPixel >= domain.rows * domain.columns) {
            return std::nullopt;
        }
        const NodeId entry = detail::kernel::anchoredEntry(tree_, anchorPixel, offset);
        return entry == InvalidNode ? std::nullopt : std::optional<NodeId>{entry};
    }
 
  private:
    void requireStableTree() const { tree_.requireMutationVersion(mutationVersion_, "ConnectedSubsetTreeLocalizer"); }
 
    const MorphologicalTree& tree_;       
    std::size_t mutationVersion_ = 0;     
};
 
} // namespace mmcfilters::local_attributes