ConformalLabpp/doc/tutorials/add-inversive-distance.md

Tutorial: Porting the Inversive-Distance Functional (Phase 9a)

This is a complete, step-by-step example of how to add a new functional to conformallab++. It ports InversiveDistanceFunctional.java from the Java reference implementation (Luo 2004).

Prerequisite: Read doc/api/extending.md first for the general pattern. This tutorial fills in every detail for one specific case.

---

Mathematical background

Inversive distance (Luo 2004) uses a different edge-length update formula:

Given inversive distances I_{ij} ∈ ℝ for each edge {i,j}:

  cosh(l̃_{ij}) = I_{ij} · cosh((u_i + u_j) / 2)
               + (cosh²((u_i - u_j) / 2) - 1) · ...

For the Euclidean version the angle formula is the same law of cosines, but the log-lengths Λ̃ are computed differently from the u-vector.

Reference: Luo, F. (2004). Combinatorial Yamabe Flow on Surfaces. Communications in Contemporary Mathematics, 6(5), 765–780.

Java source: de.varylab.discreteconformal.functional.InversiveDistanceFunctional

---

Step 1 — Create the header

cp code/include/euclidean_functional.hpp \
   code/include/inversive_distance_functional.hpp

Edit the new file:

#pragma once
// inversive_distance_functional.hpp
//
// Phase 9a — Inversive-distance discrete conformal functional (Luo 2004).
// Ported from de.varylab.discreteconformal.functional.InversiveDistanceFunctional.
//
// Usage: identical to euclidean_functional.hpp — replace lambda0 with
// inversive_distance0 (the initial inversive distances per edge).

#include "conformal_mesh.hpp"
#include <Eigen/Dense>
#include <cmath>

namespace conformallab {

struct InversiveDistanceMaps {
    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
        ::Property_map<Edge_index, double>   inv_dist0; ///< I_{ij} per edge
    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
        ::Property_map<Vertex_index, double> theta_v;   ///< target corner angles Θ_v
    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
        ::Property_map<Vertex_index, int>    v_idx;     ///< DOF index (-1 = pinned)
};

// ... (follow euclidean_functional.hpp exactly, replacing lambda0 with inv_dist0
//      and the angle formula with the Luo (2004) version)

---

Step 2 — Implement the energy, gradient, and angle formula

The Euclidean angle formula uses the law of cosines on edge lengths derived from log-lengths. For inversive distance, the edge lengths are derived from inversive distances I_{ij} and the u-vector:

// Euclidean (reference):
//   lambda_ij = lambda0_ij + u_i + u_j
//   l_ij      = exp(lambda_ij / 2)

// Inversive distance (Luo 2004):
//   cosh(l̃_ij) = I_ij * cosh((u_i + u_j) / 2)   [simplified form]
//   l̃_ij       = acosh(I_ij * cosh((u_i + u_j) / 2))

Then the corner angle at vertex k opposite edge {i,j} in triangle {i,j,k} is computed by the standard law of cosines from l̃_{ij}, l̃_{jk}, l̃_{ki}.

The gradient is the same as Euclidean:

G_v = Σ_{faces containing v} alpha_v(face, u)  −  Theta_v

---

Step 3 — Write the gradient-check test

Create code/tests/cgal/test_inversive_distance.cpp:

#include "inversive_distance_functional.hpp"
#include "mesh_factory.hpp"
#include <gtest/gtest.h>

// Finite-difference gradient check: copy the pattern from
// test_euclidean_functional.cpp :: EuclideanFunctional.GradientCheck_Triangle
TEST(InversiveDistance, GradientCheck_Triangle)
{
    // Build a single equilateral triangle (open mesh, no boundary issues).
    ConformalMesh mesh = MeshFactory::make_open_mesh(MeshFactory::Kind::triangle);
    InversiveDistanceMaps maps = setup_inversive_distance_maps(mesh);
    compute_inversive_distance0_from_mesh(mesh, maps);  // I_ij from 3D edge lengths

    const int n = /* count free DOFs */;
    std::vector<double> x0(n, 0.0);
    constexpr double eps = 1e-5;

    auto G  = inversive_distance_gradient(mesh, x0, maps);

    for (int i = 0; i < n; ++i) {
        auto xp = x0; xp[i] += eps;
        auto xm = x0; xm[i] -= eps;
        double Ep = inversive_distance_energy(mesh, xp, maps);
        double Em = inversive_distance_energy(mesh, xm, maps);
        double fd = (Ep - Em) / (2.0 * eps);
        EXPECT_NEAR(G[i], fd, 1e-6) << "gradient mismatch at DOF " << i;
    }
}

Run with:

./build/conformallab_cgal_tests --gtest_filter="InversiveDistance.*"

---

Step 4 — Register in CMakeLists

Add to code/tests/cgal/CMakeLists.txt inside the add_executable block:

    # ── Phase 9a: Inversive-distance functional ────────────────────────────────
    test_inversive_distance.cpp

---

Step 5 — Add a Newton wrapper

In code/include/newton_solver.hpp add:

/// Solve the inversive-distance conformal problem.
/// \see newton_euclidean() — identical structure.
inline NewtonResult newton_inversive_distance(
    ConformalMesh&                  mesh,
    std::vector<double>             x0,
    const InversiveDistanceMaps&    m,
    double                          tol      = 1e-8,
    int                             max_iter = 200)
{
    // Copy newton_euclidean() exactly, replacing euclidean_* with
    // inversive_distance_*.  The Hessian is PSD (Luo 2004, Thm. 1),
    // so SimplicialLDLT with SparseQR fallback applies directly.
}

---

Step 6 — Verify against Java output

The Java library outputs text results for a triangulated torus. To compare:

1. Run Java ConformalLab on the same OFF mesh with Inversive-Distance mode.
2. Record the final gradient norm and angle sums.
3. Run the C++ equivalent and check:

EXPECT_LT(res.grad_inf_norm, 1e-8);
EXPECT_LT(res.iterations, 50);  // inversive-distance converges faster than hyper-ideal

Java reference: InversiveDistanceFunctionalTest.java in de.varylab.discreteconformal.test

---

Checklist

• code/include/inversive_distance_functional.hpp compiles
• GradientCheck_Triangle passes
• GradientCheck_OpenMesh passes (copy from Euclidean tests)
• Newton converges on torus_4x4.off
• Result matches Java output (gradient norm < 1e-8 on same mesh)
• Registered in CMakeLists.txt
• doc/roadmap/java-parity.md updated: Phase 9a → ✅