SurfaceMap.hpp

#pragma once
 
#include <wmtk/history/History.hpp>
 
#include <Eigen/Core>
 
#include <array>
#include <cstdint>
#include <set>
#include <vector>
 
namespace wmtk::components::tracking {
 
struct SurfacePoint
{
    uint64_t face;
    Eigen::Vector3d bary;
};
 
struct MapWarnings
{
    size_t not_a_disk = 0;
    size_t flat_triangle = 0;
    size_t inverted = 0;
    size_t merged_faces = 0;
    size_t unlocated = 0;
    size_t replaced = 0;
 
    size_t total() const
    {
        return not_a_disk + flat_triangle + inverted + merged_faces + unlocated + replaced;
    }
};
 
enum class Smoothing {
    barycentric,
    flatten,
};
 
enum class Scaffold {
    box,
    ring,
};
 
enum class CollapsePatch {
    both_stars,
    removed_star,
};
 
struct SurfaceMapOptions
{
    Smoothing smoothing = Smoothing::flatten;
    Scaffold scaffold = Scaffold::box;
    CollapsePatch collapse_patch = CollapsePatch::both_stars;
};
 
class SurfaceMap
{
public:
    explicit SurfaceMap(const history::SurfaceHistory& h, const SurfaceMapOptions& options = {});
 
    std::vector<SurfacePoint> to_input(
        std::vector<SurfacePoint> points,
        MapWarnings* warnings = nullptr) const;
    std::vector<SurfacePoint> to_output(
        std::vector<SurfacePoint> points,
        MapWarnings* warnings = nullptr) const;
 
    const MapWarnings& build_warnings() const { return m_build_warnings; }
    const std::vector<size_t>& warned_edits() const { return m_warned_edits; }
    struct Face
    {
        uint64_t fid;
        std::array<Eigen::Vector2d, 3> uv;
        std::array<Eigen::Vector3d, 3> sub = {
            {Eigen::Vector3d::UnitX(), Eigen::Vector3d::UnitY(), Eigen::Vector3d::UnitZ()}};
    };
    struct Cell
    {
        std::vector<Face> before, after;
    };
    std::vector<const Cell*> cells_of(size_t edit) const;
 
 
    const std::vector<Eigen::Vector3d>& input_vertices() const { return m_in_vertices; }
    const std::vector<std::array<uint64_t, 3>>& input_faces() const { return m_in_faces; }
    const std::vector<uint8_t>& input_face_alive() const { return m_in_face_alive; }
    const std::vector<Eigen::Vector3d>& output_vertices() const { return m_out_vertices; }
    const std::vector<std::array<uint64_t, 3>>& output_faces() const { return m_out_faces; }
    const std::vector<uint8_t>& output_face_alive() const { return m_out_face_alive; }
    const std::set<std::array<uint64_t, 2>>& output_feature_edges() const { return m_out_features; }
 
    const std::array<size_t, 16>& cells_by_kind() const { return m_cells_by_kind; }
    size_t curve_collapses() const { return m_curve_collapses; }
    size_t kept_moves() const { return m_kept_moves; }
    size_t folded_cells() const { return m_folded_cells; }
 
private:
    struct Embedding
    {
        std::vector<std::array<Eigen::Vector3d, 3>> before, after;
        std::vector<std::vector<uint64_t>> to_after, to_before;
    };
    struct Step
    {
        history::EditKind kind;
        std::vector<Cell> cells;
        std::vector<uint64_t> old_to_new, new_to_old;
        Embedding embedding;
        std::vector<uint64_t> dead;
        std::vector<uint64_t> born;
        size_t edit = 0;
    };
 
    std::vector<SurfacePoint>
    map(std::vector<SurfacePoint> points, bool forward, MapWarnings* warnings) const;
 
    std::vector<Step> m_steps;
    MapWarnings m_build_warnings;
    std::vector<size_t> m_warned_edits;
    std::array<size_t, 16> m_cells_by_kind = {};
    size_t m_curve_collapses = 0;
    size_t m_kept_moves = 0;
    size_t m_folded_cells = 0;
 
    std::vector<Eigen::Vector3d> m_in_vertices, m_out_vertices;
    std::vector<std::array<uint64_t, 3>> m_in_faces, m_out_faces;
    std::vector<uint8_t> m_in_face_alive, m_out_face_alive;
    std::set<std::array<uint64_t, 2>> m_out_features;
};
 
} // namespace wmtk::components::tracking