ContourComputation.hpp

#pragma once
 
#include "../trees/ValuedMorphologicalTreeView.hpp"
#include "detail/ContourTraversal.hpp"
 
#include <iterator>
#include <memory>
#include <span>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
class ContourComputation {
  private:
    struct SharedIndexes {
        const MorphologicalTree& tree;
        std::size_t mutationVersion;
        contours::detail::NodeSupportIndex supportIndex;
        contours::detail::ContourLifetimeIndex contourLifetimes;
 
        explicit SharedIndexes(const MorphologicalTree& source)
            : tree(source), mutationVersion(source.getMutationVersion()), supportIndex(source), contourLifetimes(source) {}
 
        void requireStableTree() const { tree.requireMutationVersion(mutationVersion, "ContourComputation"); }
    };
 
    struct TraversalState {
        std::shared_ptr<const SharedIndexes> indexes;
        contours::detail::ContourTraversal traversal;
        bool hasCurrentContour;
 
        explicit TraversalState(std::shared_ptr<const SharedIndexes> source)
            : indexes(std::move(source)), traversal(indexes->tree, indexes->supportIndex, indexes->contourLifetimes),
              hasCurrentContour(traversal.advance()) {}
    };
 
  public:
    class iterator {
      public:
        using iterator_concept = std::input_iterator_tag;
        using iterator_category = std::input_iterator_tag;
        using value_type = std::pair<NodeId, std::span<const PixelId>>;
        using difference_type = std::ptrdiff_t;
 
        iterator() = default;
 
        [[nodiscard]] value_type operator*() const {
            if (!state_ || !state_->hasCurrentContour) {
                throw std::out_of_range("Contour iterator is exhausted.");
            }
            return state_->traversal.current();
        }
 
        iterator& operator++() {
            if (!state_ || !state_->hasCurrentContour) {
                throw std::out_of_range("Contour iterator is exhausted.");
            }
            state_->hasCurrentContour = state_->traversal.advance();
            return *this;
        }
 
        void operator++(int) { ++*this; }
 
        friend bool operator==(const iterator& it, std::default_sentinel_t) noexcept {
            return !it.state_ || !it.state_->hasCurrentContour;
        }
 
      private:
        friend class ContourComputation;
 
        explicit iterator(std::shared_ptr<const SharedIndexes> indexes) : state_(std::make_shared<TraversalState>(std::move(indexes))) {}
        std::shared_ptr<TraversalState> state_;
    };
 
    explicit ContourComputation(const MorphologicalTree& tree) : indexes_(std::make_shared<SharedIndexes>(tree)) {}
 
    template <AltitudeValue T>
    explicit ContourComputation(const ValuedMorphologicalTreeView<T>& view) : ContourComputation(currentTopology(view)) {}
 
    [[nodiscard]] std::vector<PixelId> contour(NodeId node) const {
        const auto support = indexes_->supportIndex.support(node);
        std::vector<PixelId> contourPixels;
        for (PixelId pixel : support) {
            if (indexes_->contourLifetimes.establishedIsContourPixel(pixel, node)) {
                contourPixels.push_back(pixel);
            }
        }
        return contourPixels;
    }
 
    [[nodiscard]] iterator begin() const {
        indexes_->requireStableTree();
        return iterator(indexes_);
    }
 
    [[nodiscard]] std::default_sentinel_t end() const noexcept { return {}; }
 
    template <typename Consumer> void forEachContour(Consumer&& consumer) const {
        for (auto [node, pixels] : *this) {
            consumer(node, pixels);
            indexes_->requireStableTree();
        }
    }
 
  private:
    template <AltitudeValue T> static const MorphologicalTree& currentTopology(const ValuedMorphologicalTreeView<T>& view) {
        MMCFILTERS_CONTRACT_CHECKED_ONLY(view.requireTopologyUnchanged("ContourComputation"));
        return view.topology();
    }
 
    std::shared_ptr<const SharedIndexes> indexes_;
};
 
} // namespace mmcfilters