Envelope.hpp

#pragma once
 
#include <Eigen/Core>
#include <memory>
 
// clang-format off
#include <wmtk/utils/DisableWarnings.hpp>
#include <fastenvelope/FastEnvelope.h>
#include <fastenvelope/FastEnvelope2D.h>
#include <SimpleBVH/BVH.hpp>
#include <wmtk/utils/EnableWarnings.hpp>
// clang-format on
 
namespace wmtk {
class Envelope
{
public:
    virtual ~Envelope() = default;
    virtual void init(
        const std::vector<Eigen::Vector3d>& m_ver,
        const std::vector<Eigen::Vector3i>& m_faces,
        const double) {};
    virtual bool is_outside(const std::array<Eigen::Vector3d, 3>& tris) const { return false; };
    virtual bool is_outside(const Eigen::Vector3d& pts) const { return false; };
};
 
class ExactEnvelope : public Envelope, public fastEnvelope::FastEnvelope
{
public:
    ExactEnvelope()
        : fastEnvelope::FastEnvelope::FastEnvelope() {};
    ~ExactEnvelope() {};
    void init(
        const std::vector<Eigen::Vector3d>& m_ver,
        const std::vector<Eigen::Vector3i>& m_faces,
        const double eps)
    {
        fastEnvelope::FastEnvelope::init(m_ver, m_faces, eps);
    }
    bool is_outside(const std::array<Eigen::Vector3d, 3>& tris) const
    {
        return fastEnvelope::FastEnvelope::is_outside(tris);
    }
    bool is_outside(const Eigen::Vector3d& pts) const
    {
        return fastEnvelope::FastEnvelope::is_outside(pts);
    }
};
 
 
class SampleEnvelope : public wmtk::Envelope
{
public:
    enum class Kind { Uninitialized, Triangles3d, Edges3d, Edges2d };
 
    SampleEnvelope(bool exact = false)
        : use_exact(exact) {};
    double eps2 = 1e-6;
    double eps2_edge = 1e-6;
    double sampling_dist = 1e-3;
    bool use_exact = false;
 
    bool disabled = false;
    void init(
        const std::vector<Eigen::Vector3d>& m_ver,
        const std::vector<Eigen::Vector3i>& m_faces,
        const double);
    void init(
        const std::vector<Eigen::Vector3d>& m_ver,
        const std::vector<Eigen::Vector2i>& m_edges,
        const double);
    void init(
        const std::vector<Eigen::Vector2d>& m_ver,
        const std::vector<Eigen::Vector2i>& m_edges,
        const double);
 
    void init(const Eigen::MatrixXd& V, const Eigen::MatrixXi& F, const double eps);
    bool is_outside(const std::array<Eigen::Vector3d, 3>& tris) const;
    bool is_outside(const std::array<Eigen::Vector3d, 2>& edge) const;
    virtual bool is_outside(const std::array<Eigen::Vector2d, 2>& edge) const;
    bool is_outside(const Eigen::Vector3d& pts) const;
    virtual bool is_outside(const Eigen::Vector2d& pts) const;
    double nearest_point(const Eigen::Vector3d& pts, Eigen::Vector3d& result) const;
    double nearest_point(const Eigen::Vector2d& pts, Eigen::Vector2d& result) const;
 
    double nearest_point_feature(
        const Eigen::Vector2d& p,
        Eigen::Vector2d& result,
        bool& on_corner,
        Eigen::Vector2d& seg_normal,
        int& feature_id) const;
 
    double nearest_point_feature(
        const Eigen::Vector3d& p,
        Eigen::Vector3d& result,
        int& feature_dim,
        Eigen::Vector3d& dir,
        long long& feature_id) const;
    bool initialized() { return m_bvh != nullptr; };
 
    Kind kind() const { return m_kind; }
 
    double squared_distance(const Eigen::Vector3d& p) const;
    double squared_distance(const Eigen::Vector2d& p) const;
 
private:
    void require_exact_kind(Kind expected, const char* query) const;
    void require_exact_3d(const char* query) const;
    void require_exact_built(const char* query) const;
 
    template <typename VertexList>
    void
    init_exact_edges(const VertexList& V, const std::vector<Eigen::Vector2i>& F, const double _eps);
 
    std::vector<int> geo_vertex_ind;
    std::vector<int> geo_face_ind;
    std::vector<Eigen::Vector2d> m_v2;
    std::vector<Eigen::Vector2i> m_e2;
    std::vector<Eigen::Vector3d> m_v3;
    std::vector<Eigen::Vector3i> m_f3;
    std::vector<Eigen::Vector2i> m_e3;
    std::shared_ptr<SimpleBVH::BVH> m_bvh;
 
private:
    fastEnvelope::FastEnvelope exact_envelope;
    fastEnvelope::FastEnvelope2D exact_envelope_2d;
    Kind m_kind = Kind::Uninitialized;
    bool m_exact_built = false;
};
} // namespace wmtk