EmbedSurface.hpp

#pragma once
 
#include <wmtk/io/ComponentIO.hpp>
 
#include <set>
#include <wmtk/Types.hpp>
#include <wmtk/envelope/Envelope.hpp>
#include <wmtk/history/History.hpp>
#include <wmtk/utils/Delaunay.hpp>
 
namespace wmtk::components::simwild {
 
using ImageData = std::vector<std::vector<std::vector<size_t>>>;
 
using PositionKey = std::array<std::array<double, 3>, 3>;
using FacetSources = std::vector<std::pair<PositionKey, std::vector<uint32_t>>>;
 
void delaunay_box_mesh(
    const wmtk::Envelope& envelope,
    const MatrixXd& vertices,
    std::vector<wmtk::delaunay::Point3D>& points,
    std::vector<wmtk::delaunay::Tetrahedron>& tets,
    Vector3d& box_min,
    Vector3d& box_max);
 
void embed_surface(
    const MatrixXd& V_surface,
    const MatrixXi& F_surface,
    const MatrixXd& V_vol,
    const MatrixXi& T_vol,
    MatrixXr& V_emb,
    MatrixXi& T_emb,
    MatrixXi& F_on_surface,
    const bool perform_sanity_checks = false,
    const std::vector<size_t>& F_input = {},
    std::vector<std::vector<size_t>>* F_on_surface_inputs = nullptr,
    std::vector<std::vector<int>>* F_on_surface_orientations = nullptr,
    FacetSources* facet_sources = nullptr);
 
class EmbedSurface
{
public:
    EmbedSurface(
        const std::vector<std::string>& img_filenames,
        const std::vector<Matrix4d>& img_transform = {},
        const double tol_rel = -1,
        const double tol_abs = -1,
        const bool split_connected_components = false,
        const io::ComponentIO* component_io = nullptr,
        const bool record_history = false);
 
    const history::SurfaceHistory& input_history() const { return m_input_history; }
    FacetSources& facet_sources() { return m_facet_sources; }
 
    void simplify_surface(
        const double eps,
        const bool use_exact,
        const int num_threads = 0,
        const double boundary_eps = 0);
 
    void remove_duplicates(const double eps);
 
    bool embed_surface(
        const bool flood_fill = false,
        const bool tag_from_winding_number = true,
        const bool provenance = false);
 
    void consolidate();
 
    const MatrixXd& V_emb() const { return m_V_emb; }
    const MatrixXr& V_emb_r() const { return m_V_emb_r; }
    const MatrixXd& V_surface() const { return m_V_surface; }
    const MatrixXi& T_emb() const { return m_T_emb; }
    const MatrixSi& T_tags() const { return m_T_tags; }
    const MatrixXi& F_on_surface() const { return m_F_on_surface; }
    const std::vector<std::vector<size_t>>& F_tags_surface() const { return m_F_tags_surface; }
    const std::vector<std::vector<int>>& F_tags_surface_orientation() const
    {
        return m_F_tags_surface_orientation;
    }
    const MatrixXi& F_surface() const { return m_F_surface; }
    const std::vector<size_t>& F_input() const { return m_F_input; }
 
private:
    bool m_record_history = false;
    history::SurfaceHistory m_input_history;
    FacetSources m_facet_sources;
 
public:
    void write_surf_off(const std::string& filename) const;
    void write_emb_surf_off(const std::string& filename) const;
 
    void write_emb_msh(const std::string& filename) const;
    void write_emb_vtu(const std::string& filename) const;
 
    std::pair<Vector3d, Vector3d> bbox_minmax() const;
    std::pair<Vector3d, Vector3d> bbox_surf_minmax() const;
 
    std::vector<Eigen::Vector3d> V_surf_to_vector() const;
    std::vector<std::array<size_t, 3>> F_surf_to_vector() const;
 
private:
    void V_surf_from_vector(const std::vector<Eigen::Vector3d>& verts);
    void F_surf_from_vector(const std::vector<std::array<size_t, 3>>& tris);
 
    void tag_from_winding_number();
 
    void tag_from_provenance();
 
    void check_tag_surface_invariant(const std::string& how) const;
 
private:
    std::vector<std::string> m_img_filenames;
    std::vector<ImageData> m_img_datas;
 
    // the surface separating all tags
    MatrixXd m_V_surface;
    MatrixXi m_F_surface;
 
    // per row of m_F_surface: which input it came from, or SIZE_MAX for none
    std::vector<size_t> m_F_input;
 
    // per row of m_F_on_surface: which inputs tile it, from the arrangement's provenance.
    // Only filled when the provenance tagging is asked for.
    std::vector<std::vector<size_t>> m_F_tags_surface;
    // parallel to m_F_tags_surface: each input's direction on the row (+1, -1, or 0).
    std::vector<std::vector<int>> m_F_tags_surface_orientation;
 
    std::vector<size_t> modified_nonmanifold_v;
 
    // the embedding
    MatrixXd m_V_emb;
    MatrixXr m_V_emb_r;
    MatrixXi m_T_emb;
    // triangles of the embedding representing the surface
    MatrixXi m_F_on_surface;
    // tags on the tets
    MatrixSi m_T_tags;
    std::vector<std::set<int64_t>> m_tags;
 
    // input from triangle meshes
    std::vector<MatrixXd> Vs;
    std::vector<MatrixXi> Fs;
 
public:
    bool m_smooth_surface = false;
    bool m_perform_sanity_checks = false;
    int m_num_threads = 0;
};
 
} // namespace wmtk::components::simwild