tracking.hpp

#pragma once
 
#include "CurveMap.hpp"
#include "SurfaceMap.hpp"
#include "VolumeMap.hpp"
#include "volume_io.hpp"
 
#include <wmtk/history/History.hpp>
 
#include <Eigen/Core>
#include <nlohmann/json.hpp>
#include <wmtk/MeshData.hpp>
 
#include <array>
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace wmtk::components::tracking {
 
constexpr uint64_t kNoId = std::numeric_limits<uint64_t>::max();
 
struct InputPoint
{
    uint64_t face = kNoId;
    Eigen::Vector3d bary = Eigen::Vector3d::Constant(1. / 3);
    std::array<uint64_t, 3> vertices = {{kNoId, kNoId, kNoId}};
};
 
struct OutputPoint
{
    uint64_t face = kNoId;
    std::array<uint64_t, 3> vertices = {{kNoId, kNoId, kNoId}};
    Eigen::Vector3d bary = Eigen::Vector3d::Constant(1. / 3);
};
 
class Tracking
{
public:
    explicit Tracking(const history::SurfaceHistory& h, const SurfaceMapOptions& options = {});
    static Tracking load(const std::string& path, const SurfaceMapOptions& options = {});
 
    bool output_by_vertices() const { return !m_output.ids.empty(); }
    bool input_by_vertices() const { return !m_input.ids.empty(); }
 
    std::vector<OutputPoint> to_output(
        const std::vector<InputPoint>& points,
        MapWarnings* warnings = nullptr) const;
    std::vector<InputPoint> to_input(
        const std::vector<OutputPoint>& points,
        MapWarnings* warnings = nullptr) const;
 
    std::vector<std::array<uint64_t, 3>> output_triangles() const;
 
    std::vector<std::array<uint64_t, 3>> input_triangles() const;
 
    const std::vector<std::array<uint64_t, 3>>& input_faces() const { return m_map.input_faces(); }
    const SurfaceMap& map() const { return m_map; }
 
private:
    struct Naming
    {
        std::vector<uint64_t> ids;
        std::map<uint64_t, uint64_t> history_vertex;
    };
    static SurfacePoint by_vertices(
        const Naming& naming,
        const std::vector<std::array<uint64_t, 3>>& faces,
        const std::map<std::array<uint64_t, 3>, uint64_t>& face_of,
        const std::array<uint64_t, 3>& vertices,
        const Eigen::Vector3d& bary);
    static std::map<std::array<uint64_t, 3>, uint64_t> faces_by_corners(
        const std::vector<std::array<uint64_t, 3>>& faces,
        const std::vector<uint8_t>& alive);
    static std::vector<std::array<uint64_t, 3>> triangles(
        const Naming& naming,
        const std::vector<std::array<uint64_t, 3>>& faces,
        const std::vector<uint8_t>& alive);
 
    SurfaceMap m_map;
    Naming m_output, m_input;
    std::map<std::array<uint64_t, 3>, uint64_t> m_output_face_of, m_input_face_of;
};
 
struct InputCurvePoint
{
    uint64_t segment = kNoId;
    Eigen::Vector2d bary = Eigen::Vector2d::Constant(0.5);
};
 
struct OutputCurvePoint
{
    uint64_t segment = kNoId;
    std::array<uint64_t, 2> vertices = {{kNoId, kNoId}};
    Eigen::Vector2d bary = Eigen::Vector2d::Constant(0.5);
};
 
struct FeaturePoint
{
    uint64_t input_vertex = kNoId;
    uint64_t output_vertex = kNoId;
};
 
class CurveTracking
{
public:
    explicit CurveTracking(const history::CurveHistory& h, const CurveMapOptions& options = {});
    static CurveTracking load(const std::string& path, const CurveMapOptions& options = {});
 
    bool output_by_vertices() const { return !m_output_ids.empty(); }
 
    std::vector<OutputCurvePoint> to_output(
        const std::vector<InputCurvePoint>& points,
        CurveMapWarnings* warnings = nullptr) const;
    std::vector<InputCurvePoint> to_input(
        const std::vector<OutputCurvePoint>& points,
        CurveMapWarnings* warnings = nullptr) const;
 
    std::vector<std::array<uint64_t, 2>> output_segments() const;
    const std::vector<std::array<uint64_t, 2>>& input_segments() const
    {
        return m_map.input_segments();
    }
    std::vector<FeaturePoint> feature_points() const;
    const CurveMap& map() const { return m_map; }
 
private:
    CurveMap m_map;
    std::vector<uint64_t> m_output_ids;
    std::map<uint64_t, uint64_t> m_history_vertex;
};
 
nlohmann::json warnings_report(const MapWarnings& w);
nlohmann::json warnings_report(const CurveMapWarnings& w);
nlohmann::json stats_report(const VolumeMapStats& s);
 
struct TetPoint
{
    uint64_t tet = kNoId;
    Eigen::Vector4d bary = Eigen::Vector4d::Constant(0.25);
};
 
class VolumeTracking
{
public:
    VolumeTracking(
        const history::SurfaceHistory& surface,
        history::VolumeHistory volume,
        const MeshData& input_mesh,
        const MeshData& output_mesh,
        const VolumeMapOptions& options = {});
    VolumeTracking(
        const history::SurfaceHistory& surface,
        history::VolumeHistory volume,
        const VolumeMapOptions& options = {});
    static VolumeTracking load(
        const std::string& surface_history,
        const std::string& volume_history,
        const std::string& input_mesh,
        const std::string& output_mesh,
        const VolumeMapOptions& options = {});
 
    bool has_meshes() const { return m_in.has_value(); }
    std::vector<TetPoint> to_output(const std::vector<TetPoint>& points) const;
    std::vector<TetPoint> to_input(const std::vector<TetPoint>& points) const;
    std::vector<VolumePoint> map_positions(
        const std::vector<Eigen::Vector3d>& positions,
        bool forward,
        const std::vector<uint32_t>& regions = {}) const;
 
    const VolumeMap& map() const { return *m_map; }
    const TetMeshData& input_mesh() const;
    const TetMeshData& output_mesh() const;
 
private:
    std::vector<TetPoint> map_points(const std::vector<TetPoint>& points, bool forward) const;
 
    // Shared, all of it, by a copy: the map and the meshes are not changed by mapping.
    std::shared_ptr<const VolumeMap> m_map;
    std::optional<TetLocator> m_in, m_out;
};
 
void tracking(nlohmann::json json_params);
ComponentResult tracking(nlohmann::json json_params, const MeshMap& meshes);
 
} // namespace wmtk::components::tracking