Replay.hpp

#pragma once
 
#include "History.hpp"
 
#include <array>
#include <cstdint>
#include <set>
#include <vector>
 
namespace wmtk::history {
 
template <int N>
class BasicReplay
{
public:
    using Face = typename History<N>::Face;
    using Feature = typename History<N>::Feature;
 
    explicit BasicReplay(const History<N>& h);
 
    void apply(const Edit& e);
    void apply_all(const History<N>& h);
 
    const std::vector<Eigen::Vector3d>& vertices() const { return m_vertices; }
    const std::vector<uint8_t>& vertex_alive() const { return m_vertex_alive; }
    const std::vector<Face>& faces() const { return m_faces; }
    const std::vector<uint8_t>& face_alive() const { return m_face_alive; }
    const std::vector<uint64_t>& faces_of(uint64_t v) const { return m_vertex_faces[v]; }
    std::set<Feature> features() const;
    bool is_feature(Feature f) const;
 
private:
    void split_edge(const Edit& e);
    void split_face(const Edit& e);
    void collapse_edge(const Edit& e);
    void swap_edge(const Edit& e);
    void replace_faces(const Edit& e);
    void relabel(const Edit& e);
    void embed(const Edit& e);
    void consolidate();
 
    void grow_vertices(uint64_t vid);
    void grow_faces(uint64_t fid);
    void link(uint64_t v, uint64_t f);
    void unlink(uint64_t v, uint64_t f);
    void rename_in_face(uint64_t f, uint64_t from, uint64_t to);
    void retire_bare(const std::vector<uint64_t>& vs);
 
    std::vector<Eigen::Vector3d> m_vertices;
    std::vector<uint8_t> m_vertex_alive;
    std::vector<Face> m_faces;
    std::vector<uint8_t> m_face_alive;
    std::vector<std::vector<uint64_t>> m_vertex_faces;
    std::vector<std::vector<uint64_t>> m_feature_nbrs;
    void add_feature(const Feature& f);
    bool remove_feature(const Feature& f);
    void rename_features(uint64_t from, uint64_t to);
    void drop_features(uint64_t v);
};
 
} // namespace wmtk::history