VolumeHistory.hpp

#pragma once
 
#include "History.hpp"
 
#include <Eigen/Core>
 
#include <array>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <vector>
 
namespace wmtk::history {
 
enum class VolumeOp : uint8_t {
    collapse = 0,
    swap_32 = 1,
    swap_44 = 2,
    swap_56 = 3,
    swap_23 = 4,
    smooth = 5,
};
 
struct VolumeEdit
{
    VolumeOp op = VolumeOp::collapse;
    uint64_t first_edit = 0;
    uint64_t n_edits = 0;
    std::vector<uint64_t> vertices;
    std::vector<Eigen::Vector3d> positions;
    std::vector<uint64_t> surface_before, surface_after;
    std::vector<std::pair<uint32_t, Eigen::Vector3d>> moved;
    std::vector<std::array<uint32_t, 4>> tets;
    std::vector<uint32_t> regions;
    std::vector<uint32_t> removed;
    std::vector<std::array<uint32_t, 4>> added;
    std::vector<uint32_t> added_regions;
    std::vector<uint32_t> op_vertices;
 
    std::vector<std::array<uint32_t, 4>> tets_after(
        std::vector<uint32_t>* regions_after = nullptr) const;
    std::vector<Eigen::Vector3d> positions_after() const;
};
 
struct SurfaceKey
{
    uint64_t edits = 0;
    uint64_t hash = 0;
    bool operator==(const SurfaceKey& o) const { return edits == o.edits && hash == o.hash; }
    bool operator!=(const SurfaceKey& o) const { return !(*this == o); }
};
SurfaceKey surface_key(const SurfaceHistory& h);
 
struct VolumeHistory
{
    std::vector<std::vector<int64_t>> regions;
    std::map<int64_t, std::string> tag_names;
    std::vector<VolumeEdit> edits;
    uint64_t surface_edit_offset = 0;
    std::optional<SurfaceKey> surface;
 
    void save(const std::string& path) const;
    static VolumeHistory load(const std::string& path);
    std::vector<uint8_t> to_bytes() const;
    static VolumeHistory from_bytes(const std::vector<uint8_t>& bytes);
};
 
bool is_volume_history(
    const std::vector<uint8_t>& bytes,
    const std::string& name = "the history given");
 
struct VolumeCapture
{
    std::vector<std::array<size_t, 4>> tets;
    std::vector<std::vector<int64_t>> tags;
    std::vector<size_t> vertices;
    std::vector<Eigen::Vector3d> positions;
    std::vector<uint64_t> surface;
};
 
class VolumeRecorder
{
public:
    VolumeRecorder();
    ~VolumeRecorder();
 
    using Capture = VolumeCapture;
    void commit(
        VolumeOp op,
        std::array<size_t, 2> surface_edits,
        const std::vector<size_t>& op_vertices,
        const Capture& before,
        const Capture& after);
 
    void renumber(const std::vector<size_t>& old_to_new);
 
    VolumeHistory history() const;
    std::vector<uint8_t> to_bytes(
        uint64_t surface_edit_offset,
        const SurfaceKey& surface,
        const std::map<int64_t, std::string>& tag_names) const;
    size_t size() const;
    size_t bytes() const;
 
private:
    uint32_t region_of(const std::vector<int64_t>& tags);
 
    mutable std::mutex m_mutex;
    std::vector<std::vector<int64_t>> m_regions;
    std::vector<uint64_t> m_id_of;
    uint64_t m_next_id = 0;
    std::vector<uint8_t> m_bytes;
    size_t m_count = 0;
    struct Encoder;
    std::unique_ptr<Encoder> m_encoder;
};
 
} // namespace wmtk::history