History.hpp

#pragma once
 
#include "Fwd.hpp"
 
#include <Eigen/Core>
 
#include <array>
#include <cstdint>
#include <filesystem>
#include <mutex>
#include <string>
#include <vector>
 
namespace wmtk::history {
 
enum class EditKind : uint8_t {
    split_edge = 1,
    split_face = 2,
    collapse_edge = 3,
    swap_edge = 4,
    move_vertices = 5,
    consolidate = 6,
    replace_faces = 7,
    relabel = 8,
    embed = 9,
};
 
constexpr uint64_t kNoVertex = uint64_t(-1);
 
struct VertexMove
{
    uint64_t vid;
    Eigen::Vector3d pos;
};
 
struct Edit
{
    EditKind kind;
    std::vector<uint64_t> v;
    std::vector<uint64_t> faces;
    std::vector<VertexMove> moves;
};
 
template <int N>
struct History
{
    static_assert(N == 2 || N == 3, "a history is of triangles or of segments");
    using Face = std::array<uint64_t, N>;
    using Feature = std::array<uint64_t, N - 1>;
 
    std::vector<Eigen::Vector3d> vertices;
    std::vector<uint8_t> vertex_alive;
    std::vector<Face> faces;
    std::vector<uint8_t> face_alive;
    std::vector<Feature> features;
 
    std::vector<Edit> edits;
 
    std::string metadata;
 
    std::vector<uint64_t> output_vertex_ids;
    std::vector<uint64_t> input_vertex_ids;
 
    void save(const std::string& path) const;
    static History load(const std::string& path);
    std::vector<uint8_t> to_bytes() const;
    static History from_bytes(const std::vector<uint8_t>& bytes);
};
 
std::vector<uint8_t> read_history(const std::filesystem::path& path);
void write_history(const std::filesystem::path& path, const std::vector<uint8_t>& bytes);
 
int face_size(const std::string& path);
int face_size(const std::vector<uint8_t>& bytes);
 
template <int N>
bool append(History<N>& h, const History<N>& next);
 
template <int N>
void append_embedded(
    History<N>& h,
    const History<N>& next,
    const std::vector<std::vector<uint64_t>>& sources);
 
template <int N>
class BasicRecorder
{
public:
    explicit BasicRecorder(History<N> start);
 
    void append(Edit&& e);
 
    void rebase(std::vector<Eigen::Vector3d> positions);
 
    const History<N>& history() const { return m_history; }
    History<N>& history() { return m_history; }
 
private:
    std::mutex m_mutex;
    History<N> m_history;
    std::vector<Eigen::Vector3d> m_known;
    std::vector<uint8_t> m_known_valid;
};
 
} // namespace wmtk::history