BoundaryEnvelope.hpp

#pragma once
 
#include <wmtk/TriMesh.h>
#include <wmtk/envelope/Envelope.hpp>
 
#include <Eigen/Core>
 
#include <array>
#include <cstddef>
#include <vector>
 
namespace wmtk {
 
class BoundaryEnvelope
{
public:
    template <typename VertexAttributes>
    bool init(const TriMesh& m, VertexAttributes& vertex_attrs, double eps, bool use_exact)
    {
        std::vector<Eigen::Vector2i> E;
        for (const TriMesh::Tuple& e : m.get_edges()) {
            if (!m.is_boundary_edge(e)) continue;
            const size_t a = e.vid(m), b = e.switch_vertex(m).vid(m);
            E.emplace_back(int(a), int(b));
            vertex_attrs[a].input_boundary = true;
            vertex_attrs[b].input_boundary = true;
        }
        if (E.empty()) {
            m_initialized = false;
            return false;
        }
        std::vector<Eigen::Vector3d> V(m.vert_capacity());
        for (size_t i = 0; i < V.size(); ++i) {
            V[i] = vertex_attrs[i].pos;
        }
        build(V, E, eps, use_exact);
        return true;
    }
 
    bool initialized() const { return m_initialized; }
 
    void set_use_exact(bool use_exact) { m_envelope.use_exact = use_exact; }
 
    template <typename VertexAttributes>
    bool boundary_edges_inside(
        const TriMesh& m,
        const VertexAttributes& vertex_attrs,
        const std::vector<TriMesh::Tuple>& tris) const
    {
        if (!m_initialized) return true;
        for (const TriMesh::Tuple& t : tris) {
            for (int j = 0; j < 3; ++j) {
                const TriMesh::Tuple e = m.tuple_from_edge(t.fid(m), j);
                const size_t a = e.vid(m), b = e.switch_vertex(m).vid(m);
                if (!vertex_attrs[a].input_boundary && !vertex_attrs[b].input_boundary) continue;
                if (!m.is_boundary_edge(e)) continue;
                const std::array<Eigen::Vector3d, 2> seg{
                    {vertex_attrs[a].pos, vertex_attrs[b].pos}};
                if (m_envelope.is_outside(seg)) return false;
            }
        }
        return true;
    }
 
    template <typename VertexAttributes>
    static bool on_input_boundary(
        const TriMesh& m,
        const VertexAttributes& vertex_attrs,
        const TriMesh::Tuple& v)
    {
        return vertex_attrs[v.vid(m)].input_boundary && m.is_boundary_vertex(v);
    }
 
private:
    void build(
        const std::vector<Eigen::Vector3d>& V,
        const std::vector<Eigen::Vector2i>& E,
        double eps,
        bool use_exact);
 
    Envelope m_envelope;
    bool m_initialized = false;
};
 
} // namespace wmtk