CurveMap.hpp

#pragma once
 
#include "SurfaceMap.hpp"
 
#include <wmtk/history/History.hpp>
 
#include <Eigen/Core>
 
#include <array>
#include <cstdint>
#include <utility>
#include <vector>
 
namespace wmtk::components::tracking {
 
struct CurvePoint
{
    uint64_t segment;
    Eigen::Vector2d bary;
};
 
struct CurveMapWarnings
{
    size_t topology = 0;
    size_t merged_segments = 0;
    size_t overlapping = 0;
    size_t unlocated = 0;
    size_t replaced = 0;
 
    size_t total() const { return topology + merged_segments + overlapping + unlocated + replaced; }
};
 
struct CurveMapOptions
{
    Smoothing smoothing = Smoothing::flatten;
};
 
class CurveMap
{
public:
    explicit CurveMap(const history::CurveHistory& h, const CurveMapOptions& options = {});
 
    std::vector<CurvePoint> to_input(
        std::vector<CurvePoint> points,
        CurveMapWarnings* warnings = nullptr) const;
    std::vector<CurvePoint> to_output(
        std::vector<CurvePoint> points,
        CurveMapWarnings* warnings = nullptr) const;
 
    const CurveMapWarnings& build_warnings() const { return m_build_warnings; }
    const std::vector<size_t>& warned_edits() const { return m_warned_edits; }
 
    const std::vector<Eigen::Vector3d>& input_vertices() const { return m_in_vertices; }
    const std::vector<std::array<uint64_t, 2>>& input_segments() const { return m_in_segments; }
    const std::vector<uint8_t>& input_segment_alive() const { return m_in_alive; }
    const std::vector<Eigen::Vector3d>& output_vertices() const { return m_out_vertices; }
    const std::vector<std::array<uint64_t, 2>>& output_segments() const { return m_out_segments; }
    const std::vector<uint8_t>& output_segment_alive() const { return m_out_alive; }
 
    const std::vector<std::array<uint64_t, 2>>& feature_points() const { return m_features; }
    const std::vector<uint64_t>& output_feature_points() const { return m_out_features; }
 
    const std::array<size_t, 16>& steps_by_kind() const { return m_steps_by_kind; }
 
private:
    struct Chain
    {
        std::vector<uint64_t> segments;
        std::vector<uint8_t> forward;
        std::vector<double> start, length;
        double total = 0;
    };
    static void measure(Chain& c);
    struct Image
    {
        uint64_t segment;
        bool flipped;
    };
    using Place = std::pair<uint32_t, uint32_t>;
    struct Step
    {
        history::EditKind kind;
        std::vector<std::pair<Chain, Chain>> chains;
        std::vector<std::pair<uint64_t, Place>> before_at, after_at;
        std::vector<std::pair<uint64_t, Image>> forward, backward;
        std::vector<Image> old_to_new, new_to_old;
        std::vector<std::array<Eigen::Vector3d, 2>> before, after;
        std::vector<std::vector<uint64_t>> to_after, to_before;
    };
 
    void build_local(history::CurveReplay& r, const history::Edit& e, Step& step, bool flatten);
    void build_renumbering(history::CurveReplay& r, const history::Edit& e, Step& step);
    void build_embed(history::CurveReplay& r, const history::Edit& e, Step& step);
    void build_replace(history::CurveReplay& r, const history::Edit& e, Step& step);
 
    static bool forward(const Step& s, CurvePoint& p);
    static bool backward(const Step& s, CurvePoint& p);
    void map(std::vector<CurvePoint>& points, bool to_output, CurveMapWarnings& warnings) const;
    static CurvePoint
    along(const Chain& from, size_t i, const Eigen::Vector2d& bary, const Chain& to);
 
    std::vector<Step> m_steps;
    CurveMapWarnings m_build_warnings;
    std::vector<size_t> m_warned_edits;
    std::vector<Eigen::Vector3d> m_in_vertices, m_out_vertices;
    std::vector<std::array<uint64_t, 2>> m_in_segments, m_out_segments;
    std::vector<uint8_t> m_in_alive, m_out_alive;
    std::vector<std::array<uint64_t, 2>> m_features;
    std::vector<uint64_t> m_out_features;
    std::array<size_t, 16> m_steps_by_kind = {};
};
 
} // namespace wmtk::components::tracking