MeshUtils.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/mesh/Mesh.hpp>
#include <polyfem/mesh/mesh3D/Navigation3D.hpp>
#include <geogram/mesh/mesh.h>
#include <Eigen/Dense>
#include <vector>
#include <memory>
 
namespace polyfem
{
 
    namespace mesh
    {
        class Mesh2D;
        class Mesh3D;
 
        GEO::vec3 mesh_vertex(const GEO::Mesh &M, GEO::index_t v);
 
        // Compute facet barycenter.
        //
        // @param[in]  M      Input mesh
        // @param[in]  f      Facet whose barycenter to compute
        //
        // @return     Barycenter position in 3D
        //
        GEO::vec3 facet_barycenter(const GEO::Mesh &M, GEO::index_t f);
 
        // Create a new mesh vertex with given coordinates.
        //
        // @param      M     Mesh to modify
        // @param[in]  p      New vertex position
        //
        // @return     Index of the newly created vertex
        //
        GEO::index_t mesh_create_vertex(GEO::Mesh &M, const GEO::vec3 &p);
 
        void compute_element_tags(const GEO::Mesh &M, std::vector<ElementType> &element_tags);
 
        void orient_normals_2d(GEO::Mesh &M);
 
        void reorder_mesh(Eigen::MatrixXd &V, Eigen::MatrixXi &F, const Eigen::VectorXi &C, Eigen::VectorXi &R);
 
        void signed_squared_distances(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F,
                                      const Eigen::MatrixXd &P, Eigen::VectorXd &D);
 
        void to_geogram_mesh(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, GEO::Mesh &M);
        // void to_geogram_mesh_3d(const Eigen::MatrixXd &V, const Eigen::MatrixXi &C, GEO::Mesh &M);
 
        void from_geogram_mesh(const GEO::Mesh &M, Eigen::MatrixXd &V, Eigen::MatrixXi &F, Eigen::MatrixXi &T);
 
        void to_geogram_mesh(const Mesh3D &mesh, GEO::Mesh &M);
 
        double signed_volume(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F);
 
        void orient_closed_surface(const Eigen::MatrixXd &V, Eigen::MatrixXi &F, bool positive = true);
 
        void extract_polyhedra(const Mesh3D &mesh, std::vector<std::unique_ptr<GEO::Mesh>> &polys, bool triangulated = false);
 
        std::vector<std::pair<Navigation::Index, Navigation::Index>> compute_mesh_interface(
            const Mesh2D &first, const Mesh2D &second);
 
        std::vector<std::pair<Navigation3D::Index, Navigation3D::Index>> compute_mesh_interface(
            const Mesh3D &first, const Mesh3D &second);
 
        void sample_surface(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, int num_samples,
                            Eigen::MatrixXd &P, Eigen::MatrixXd *N = nullptr, int num_lloyd = 10, int num_newton = 10);
 
        void extract_parent_edges(const Eigen::MatrixXd &IV, const Eigen::MatrixXi &IE,
                                  const Eigen::MatrixXd &BV, const Eigen::MatrixXi &BE, Eigen::MatrixXi &OE);
 
        void extract_triangle_surface_from_tets(
            const Eigen::MatrixXd &vertices,
            const Eigen::MatrixXi &tets,
            Eigen::MatrixXd &surface_vertices,
            Eigen::MatrixXi &tris);
 
        bool read_surface_mesh(const std::string &mesh_path, Eigen::MatrixXd &vertices, Eigen::VectorXi &codim_vertices, Eigen::MatrixXi &codim_edges, Eigen::MatrixXi &faces);
 
        bool is_planar(const GEO::Mesh &M, const double tol = 1e-5);
 
        int count_faces(const int dim, const Eigen::MatrixXi &cells);
 
        void generate_edges(GEO::Mesh &M);
    } // namespace mesh
} // namespace polyfem