RicciFlow.h

#pragma once

#include <CGAL/boost/graph/Seam_mesh.h>
#include <CGAL/Surface_mesh_parameterization/Error_code.h>

namespace Euclid
{
template<typename Mesh, typename VertexRadiusMap, typename EdgeWeightMap>
void circle_packing_metric(Mesh& mesh, VertexRadiusMap vrm, EdgeWeightMap ewm);

template<typename Mesh,
         typename VertexRadiusMap,
         typename EdgeWeightMap,
         typename SEM,
         typename SVM,
         typename VertexUVMap>
void embed_circle_packing_metric(const Mesh& mesh,
                                 VertexRadiusMap vrm,
                                 EdgeWeightMap ewm,
                                 CGAL::Seam_mesh<Mesh, SEM, SVM>& seam_mesh,
                                 VertexUVMap uvm);

enum class RicciFlowSolverType
{
    GradientDescent,
    Newton
};

struct RicciFlowSolverSettings
{
    RicciFlowSolverType type = RicciFlowSolverType::GradientDescent;
    double step = 5e-2;
    double eps = 1e-5;
    int max_iters = 5000;
    bool verbose = false;
};

enum class RicciFlowSolverStatus
{
    Optimal,
    Suboptimal,
    InvalidInput,
};

template<typename Mesh,
         typename VertexRadiusMap,
         typename EdgeWeightMap,
         typename VertexCurvatureMap>
RicciFlowSolverStatus ricci_flow(
    Mesh& mesh,
    VertexRadiusMap vrm,
    EdgeWeightMap ewm,
    VertexCurvatureMap vcm,
    const RicciFlowSolverSettings& settings = RicciFlowSolverSettings());

template<typename Mesh, typename SEM, typename SVM>
class Ricci_flow_parameterizer3
{
public:
    using TriangleMesh = CGAL::Seam_mesh<Mesh, SEM, SVM>;
    using halfedge_descriptor =
        typename boost::graph_traits<TriangleMesh>::halfedge_descriptor;
    using Scalar = typename CGAL::Kernel_traits<typename boost::property_traits<
        typename boost::property_map<Mesh, boost::vertex_point_t>::type>::
                                                    value_type>::Kernel::FT;

public:
    explicit Ricci_flow_parameterizer3(const Mesh& mesh);

    void set_solver_settings(const RicciFlowSolverSettings& settings);

    void add_cone(typename boost::graph_traits<Mesh>::vertex_descriptor v,
                  Scalar k);

    template<typename VertexUVMap,
             typename VertexIndexMap,
             typename VertexParameterizedMap>
    CGAL::Surface_mesh_parameterization::Error_code parameterize(
        TriangleMesh& mesh,
        halfedge_descriptor bhd,
        VertexUVMap uvmap,
        VertexIndexMap vimap,
        VertexParameterizedMap vpmap);

private:
    using vd = typename boost::graph_traits<Mesh>::vertex_descriptor;
    using ed = typename boost::graph_traits<Mesh>::edge_descriptor;
    using VRM = std::map<vd, Scalar>;
    using VRPM = boost::associative_property_map<VRM>;
    using EWM = std::map<ed, Scalar>;
    using EWPM = boost::associative_property_map<EWM>;
    using VCM = std::map<vd, Scalar>;
    using VCPM = boost::associative_property_map<VCM>;

private:
    const Mesh& _underlying_mesh;
    RicciFlowSolverSettings _settings;
    VRM _vrm;
    VRPM _vrpm;
    EWM _ewm;
    EWPM _ewpm;
    VCM _vcm;
    VCPM _vcpm;
};

} // namespace Euclid

#include "src/RicciFlow.cpp"