SimplexCollection.hpp

#pragma once
 
#include <cassert>
#include "Simplex.hpp"
 
namespace wmtk::simplex {
 
class SimplexCollection
{
public:
    SimplexCollection() = default;
 
    // SimplexCollection(std::vector<Simplex>&& simplices = {})
    //     : m_simplices(std::move(simplices))
    //{}
 
    // const std::vector<Simplex>& simplex_vector() const { return m_simplices; }
 
    const std::vector<Vertex>& vertices() const;
    const std::vector<Edge>& edges() const;
    const std::vector<Face>& faces() const;
    const std::vector<Tet>& tets() const;
 
    void reserve_vertices(size_t new_capacity) { m_v.reserve(new_capacity); }
    void reserve_edges(size_t new_capacity) { m_e.reserve(new_capacity); }
    void reserve_faces(size_t new_capacity) { m_f.reserve(new_capacity); }
    void reserve_tets(size_t new_capacity) { m_t.reserve(new_capacity); }
 
    void add(const Vertex& s) { m_v.emplace_back(s); }
    void add(const Edge& s) { m_e.emplace_back(s); }
    void add(const Face& s) { m_f.emplace_back(s); }
    void add(const Tet& s) { m_t.emplace_back(s); }
    // The faces are appended straight into this collection. Going through
    // faces_from_simplex() would build a whole temporary SimplexCollection -- three heap
    // allocations for a Tet -- copy it in, and destroy it; TetMeshSubstructure's link
    // computation calls this ten times per edge.
    void add_with_faces(const Edge& s)
    {
        add(s);
        const auto& v = s.vertices();
        m_v.emplace_back(Vertex(v[0]));
        m_v.emplace_back(Vertex(v[1]));
    }
    void add_with_faces(const Face& s)
    {
        add(s);
        const auto& v = s.vertices();
        m_v.emplace_back(Vertex(v[0]));
        m_v.emplace_back(Vertex(v[1]));
        m_v.emplace_back(Vertex(v[2]));
        m_e.emplace_back(Edge(v[0], v[1]));
        m_e.emplace_back(Edge(v[0], v[2]));
        m_e.emplace_back(Edge(v[1], v[2]));
    }
    void add_with_faces(const Tet& s)
    {
        add(s);
        const auto& v = s.vertices();
        m_v.emplace_back(Vertex(v[0]));
        m_v.emplace_back(Vertex(v[1]));
        m_v.emplace_back(Vertex(v[2]));
        m_v.emplace_back(Vertex(v[3]));
        m_e.emplace_back(Edge(v[0], v[1]));
        m_e.emplace_back(Edge(v[0], v[2]));
        m_e.emplace_back(Edge(v[0], v[3]));
        m_e.emplace_back(Edge(v[1], v[2]));
        m_e.emplace_back(Edge(v[1], v[3]));
        m_e.emplace_back(Edge(v[2], v[3]));
        m_f.emplace_back(Face(v[0], v[1], v[2]));
        m_f.emplace_back(Face(v[0], v[1], v[3]));
        m_f.emplace_back(Face(v[0], v[2], v[3]));
        m_f.emplace_back(Face(v[1], v[2], v[3]));
    }
 
    void add(const SimplexCollection& simplex_collection);
 
    void sort_and_clean();
 
    bool contains(const Vertex& simplex) const
    {
        assert(std::is_sorted(m_v.begin(), m_v.end()));
        return std::binary_search(m_v.begin(), m_v.end(), simplex);
    }
    bool contains(const Edge& simplex) const
    {
        assert(std::is_sorted(m_e.begin(), m_e.end()));
        return std::binary_search(m_e.begin(), m_e.end(), simplex);
    }
    bool contains(const Face& simplex) const
    {
        assert(std::is_sorted(m_f.begin(), m_f.end()));
        return std::binary_search(m_f.begin(), m_f.end(), simplex);
    }
    bool contains(const Tet& simplex) const
    {
        assert(std::is_sorted(m_t.begin(), m_t.end()));
        return std::binary_search(m_t.begin(), m_t.end(), simplex);
    }
 
    static SimplexCollection get_union(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
    static SimplexCollection get_intersection(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
    static bool are_simplex_collections_equal(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
    template <int N>
    static SimplexCollection faces_from_simplex(const Simplex<N>& simplex);
 
    std::vector<Face> faces_with_edge(const Edge& e) const;
 
    size_t size() const;
    bool empty() const { return size() == 0; }
 
    bool operator==(const SimplexCollection& that) const;
    bool operator!=(const SimplexCollection& that) const;
 
private:
    std::vector<Vertex> m_v;
    std::vector<Edge> m_e;
    std::vector<Face> m_f;
    std::vector<Tet> m_t;
};
 
template <int N>
inline SimplexCollection SimplexCollection::faces_from_simplex(const Simplex<N>& simplex)
{
    const auto& v = simplex.vertices();
 
    SimplexCollection sc;
 
    if constexpr (N == 1) {
        // do nothing
    } else if constexpr (N == 2) {
        sc.m_v.emplace_back(Vertex(v[0]));
        sc.m_v.emplace_back(Vertex(v[1]));
    } else if constexpr (N == 3) {
        sc.m_v.emplace_back(Vertex(v[0]));
        sc.m_v.emplace_back(Vertex(v[1]));
        sc.m_v.emplace_back(Vertex(v[2]));
        sc.m_e.emplace_back(Edge(v[0], v[1]));
        sc.m_e.emplace_back(Edge(v[0], v[2]));
        sc.m_e.emplace_back(Edge(v[1], v[2]));
    } else {
        static_assert(N == 4);
 
        sc.m_v.emplace_back(Vertex(v[0]));
        sc.m_v.emplace_back(Vertex(v[1]));
        sc.m_v.emplace_back(Vertex(v[2]));
        sc.m_v.emplace_back(Vertex(v[3]));
        sc.m_e.emplace_back(Edge(v[0], v[1]));
        sc.m_e.emplace_back(Edge(v[0], v[2]));
        sc.m_e.emplace_back(Edge(v[0], v[3]));
        sc.m_e.emplace_back(Edge(v[1], v[2]));
        sc.m_e.emplace_back(Edge(v[1], v[3]));
        sc.m_e.emplace_back(Edge(v[2], v[3]));
        sc.m_f.emplace_back(Face(v[0], v[1], v[2]));
        sc.m_f.emplace_back(Face(v[0], v[1], v[3]));
        sc.m_f.emplace_back(Face(v[0], v[2], v[3]));
        sc.m_f.emplace_back(Face(v[1], v[2], v[3]));
    }
 
    return sc;
}
 
} // namespace wmtk::simplex