TrackedRecorder.hpp

#pragma once
 
#include "History.hpp"
#include "Replay.hpp"
 
#include <Eigen/Core>
 
#include <array>
#include <cstdint>
#include <functional>
#include <mutex>
#include <optional>
#include <vector>
 
namespace wmtk::history {
 
template <int N>
class TrackedRecorder
{
public:
    using Cell = std::array<size_t, N>;
    using MeshFeature = std::array<size_t, N - 1>;
    using Positions = std::function<Eigen::Vector3d(size_t)>;
    using Orient = std::function<Cell(const Cell&)>;
 
    TrackedRecorder(
        const std::vector<Cell>& faces,
        Positions position,
        Orient orient,
        const std::vector<MeshFeature>& features = {});
 
    std::vector<MeshFeature> features() const;
    std::vector<uint64_t> mesh_vertex_ids() const;
 
    struct Change
    {
        EditKind kind = EditKind::move_vertices;
        std::vector<size_t> v;
        std::vector<Cell> before, after;
        std::vector<size_t> written;
    };
    std::array<size_t, 2> commit(Change&& c);
 
    void renumber(const std::vector<size_t>& old_to_new);
 
    size_t resync(const std::vector<Cell>& faces);
 
    struct Stats
    {
        size_t split = 0, collapse = 0, swap = 0, move = 0;
        size_t weld = 0;
        size_t replaced = 0;
        size_t unknown = 0;
    };
    Stats stats() const;
 
    const History<N>& history() const { return m_history; }
    History<N>& history() { return m_history; }
    const BasicReplay<N>& complex() const { return m_replay; }
 
    std::optional<uint64_t> face_id(const Cell& t) const;
    std::optional<uint64_t> vertex_id(size_t v) const;
    std::vector<uint64_t> vertex_ids(const std::vector<size_t>& vs) const;
 
private:
    static constexpr uint64_t kNone = uint64_t(-1);
 
    std::optional<uint64_t> live(size_t v) const;
    std::optional<uint64_t> lookup(const Cell& t) const;
    uint64_t fresh_vertex(size_t v);
    std::optional<Edit> as_split(
        const Change& c,
        const std::vector<Cell>& before,
        const std::vector<Cell>& removed,
        const std::vector<Cell>& added,
        std::vector<uint64_t>& fresh);
    std::optional<Edit>
    as_collapse(Change& c, const std::vector<Cell>& before, const std::vector<Cell>& after);
    std::optional<Edit> as_swap(const std::vector<Cell>& removed, const std::vector<Cell>& added);
    void record(Edit&& e, const std::vector<size_t>& written, const std::vector<uint64_t>& fresh);
    Edit replacement(
        const std::vector<Cell>& removed,
        const std::vector<Cell>& added,
        std::vector<uint64_t>& fresh);
 
    mutable std::mutex m_mutex;
    Positions m_position;
    Orient m_orient;
    std::vector<uint64_t> m_complex_of;
    std::vector<size_t> m_mesh_of;
    History<N> m_history;
    BasicReplay<N> m_replay;
    std::vector<Eigen::Vector3d> m_known;
    uint64_t m_next_face = 0;
    Stats m_stats;
};
 
} // namespace wmtk::history