Refinement.hpp

Go to the documentation of this file.

#pragma once
 
#include <geogram/mesh/mesh.h>
#include <Eigen/Dense>
#include <vector>
 
namespace polyfem
{
    namespace mesh
    {
 
        // Compute a graph (V,E) where V are the edges of the input quad mesh, and E
        // connects edges from opposite sides of the input quads.
        //
        // @param[in]  Q                #Q x 4 input quads
        // @param[out] edge_index       Map (f, lv) -> edge index for edge (lv, lv+1)
        // @param[out] adj              Adjacency graph
        // @param[out] pairs_of_edges  { List of mesh edges, corresponding to the
        //                             vertices of the output graph }
        // @param[out] pairs_of_quads   List of adjacent quads
        // @param[out] quad_index      { Map (f, lv) -> index of the quad across edge
        //                             (lv, lv+1) }
        //
        void edge_adjacency_graph(const Eigen::MatrixXi &Q, Eigen::MatrixXi &edge_index,
                                  std::vector<std::vector<int>> &adj,
                                  std::vector<std::pair<int, int>> *pairs_of_edges = nullptr,
                                  std::vector<std::pair<int, int>> *pairs_of_quads = nullptr,
                                  Eigen::MatrixXi *quad_index = nullptr);
 
        typedef std::function<void(const Eigen::MatrixXd &, Eigen::MatrixXd &, int)> EvalParametersFunc;
        typedef std::function<std::tuple<int, int, bool>(int, int)> GetAdjacentLocalEdge;
 
        // Instantiate a periodic 2D pattern (triangle-mesh) on a given quad mesh
        //
        // @param[in]  IV         #IV x 3 input quad mesh vertices
        // @param[in]  IF         #IF x 4 input quad mesh facets
        // @param[in]  PV         #PV x (2|3) input pattern vertices in [0,1]^2
        // @param[in]  PF         #PF x (3|4) input pattern facets
        // @param[out] OV         #OV x 3 output mesh vertices
        // @param[out] OF         #OF x 3 output mesh facets
        // @param[in]  SF         #OV x 1 matrix of input source quad index, filled if pointer is non-zero
        // @param[in]  evalFunc  { Evaluate the uv param of the pattern into a 2d or 3d
        //                       position }
        //
        // @return     { Return true in case of success. }
        //
        bool instantiate_pattern(
            const Eigen::MatrixXd &IV, const Eigen::MatrixXi &IF,
            const Eigen::MatrixXd &PV, const Eigen::MatrixXi &PF,
            Eigen::MatrixXd &OV, Eigen::MatrixXi &OF,
            Eigen::VectorXi *SF = nullptr,
            EvalParametersFunc evalFunc = nullptr,
            GetAdjacentLocalEdge getAdjLocalEdge = nullptr);
 
        //
        // Refine a quad-mesh by splitting each quad into 4 quads.
        //
        // @param[in]  IV     #IV x 3 input quad mesh vertices
        // @param[in]  IF     #IF x 4 input quad mesh facets
        // @param[out] OV     #OV x 3 output mesh vertices
        // @param[out] OF     #OF x 4 output mesh facets
        //
        void refine_quad_mesh(const Eigen::MatrixXd &IV, const Eigen::MatrixXi &IF,
                              Eigen::MatrixXd &OV, Eigen::MatrixXi &OF);
 
        namespace Polygons
        {
 
            typedef std::function<void(Eigen::MatrixXd &IV, Eigen::MatrixXd &OV, std::vector<std::vector<int>> &OF)> SplitFunction;
 
            void polar_split(const Eigen::MatrixXd &IV, Eigen::MatrixXd &OV, std::vector<std::vector<int>> &OF, double t = 0.5);
 
            inline SplitFunction polar_split_func(double t)
            {
                return [t](const Eigen::MatrixXd &IV, Eigen::MatrixXd &OV, std::vector<std::vector<int>> &OF) { polar_split(IV, OV, OF, t); };
            }
 
            void catmul_clark_split(const Eigen::MatrixXd &IV, Eigen::MatrixXd &OV, std::vector<std::vector<int>> &OF);
 
            inline SplitFunction catmul_clark_split_func() { return SplitFunction(catmul_clark_split); }
 
            void no_split(const Eigen::MatrixXd &IV, Eigen::MatrixXd &OV, std::vector<std::vector<int>> &OF);
 
            inline SplitFunction no_split_func() { return SplitFunction(no_split); }
        } // namespace Polygons
 
        void refine_polygonal_mesh(const GEO::Mesh &M_in, GEO::Mesh &M_out, Polygons::SplitFunction split_func);
 
        void refine_triangle_mesh(const GEO::Mesh &M_in, GEO::Mesh &M_out);
 
        // Kept for compatibility
        [[deprecated]] inline void refine_polygonal_mesh(const GEO::Mesh &M_in, GEO::Mesh &M_out, bool refine_polygons = false, double t = 0.5)
        {
            if (refine_polygons == false)
            {
                refine_polygonal_mesh(M_in, M_out, Polygons::no_split_func());
            }
            else
            {
                refine_polygonal_mesh(M_in, M_out, Polygons::polar_split_func(t));
            }
        }
    } // namespace mesh
} // namespace polyfem