Geometry Processing and Geometric Deep Learning

Contents

• Introduction and overview
• 0. Review: calculus on surfaces, linear algebra and convolution
• 1. Triangle meshes and discrete differential operators
• 2. Heat diffusion, geodesics and convolution on surfaces
• 3. Spectral geometry, curvature and spectral signatures
• 4. Deformation, parameterization and topology
• 5. Maps between surfaces and shape matching
• 6. Deep learning on curved surfaces
• 7. Architectures and applications: from PointNet to DiffusionNet
• 8. Neural fields for surfaces
• 9. Generative modelling of geometry
• 10. Research directions and open problems
• Exercises
• Projects and assessment
• References

Introduction and overview

Audience: a student with an M1 in mathematics, computer science or physics who knows linear algebra, multivariable calculus and the basics of neural networks, and who wants to analyse, match, learn on and generate 3D shapes.

Empirical first: a body scanned in two poses has completely different (x, y, z) coordinates but almost the same geodesic distances on the surface, so a network built from the Laplace–Beltrami operator is blind to the pose, while a coordinate-based one must learn every pose. The same operator makes a network indifferent to the mesh: trained on an 800-vertex mesh, the small network of Code 7.9 reaches 96 % accuracy on a 2500-vertex mesh of the same surface that it never saw.

The course builds the calculus of surfaces on triangle meshes (gradients, Laplacians, curvature, geodesics), uses it to deform, flatten and match shapes, turns the same operators into network layers, and ends with neural fields and generative models. It complements Geometric Data Analysis (distances between shapes), Point Clouds and 3D Modelling (acquisition and reconstruction) and Deep Learning (learning on grids).

What you will be able to do

• Assemble the cotangent Laplacian, the mass matrix, the gradient and the divergence of a triangle mesh from the finite element method, and state their properties.
• Compute heat diffusion, geodesic distances with the heat method, and spectral filters on a surface.
• Compute discrete mean and Gaussian curvature and prove the discrete Gauss–Bonnet theorem.
• Build the heat, wave and global point signatures and explain why they are invariant to isometries.
• Deform a mesh with the as-rigid-as-possible energy and flatten a disk-like mesh with Tutte’s method, and explain the topological obstructions to flattening.
• Compute a functional map between two shapes and convert it into a point-to-point correspondence.
• Define parallel transport on a mesh, prove that its holonomy equals the angle defect, and build gauge-equivariant layers.
• Compare PointNet, graph networks, MeshCNN, SpiralNet++, DiffusionNet and DeltaConv, and train an operator-based network.
• Fit neural signed distance fields with Fourier features, SIREN and eikonal regularisation, and write the NeRF rendering equation.
• Explain how meshes are generated and made differentiable, and fit a template mesh to a point cloud.
• Reimplement a research paper of the field and evaluate it, as the course project asks.

Official objectives and syllabus (2026–2027)

The course description on master-mva.com sets the objective of introducing advanced topics in modern geometric data analysis, the field known as Geometry Processing. It focuses on mathematical foundations (discrete differential geometry, mapping, optimization) and on the deep learning methods that perform best.

The description announces an overview of surface-based analysis and processing, then modern deep learning techniques for 3D shape classification, correspondence and parametrization, and finally recent approaches for generating geometry from both the mesh and the shape perspectives. It lists six lectures, each with practical sessions (TPs), and the themes (“Thèmes abordés”) matched below. The Université Paris-Saclay course detail gives the volume (12 h of lectures, 14 h of labs) and the nature of the assessment, but no programme items.

Beyond the syllabus, this page adds a review chapter (ch. 0), a research chapter for self-study (ch. 10), proofs of the central discrete theorems, and a written-exam proposal.

Where this course fits in the programme

Official prerequisites: not displayed. The course page lists Etienne Corman (CNRS, LORIA), Julie Digne (CNRS, LIRIS) and Maks Ovsjanikov (École Polytechnique, LIX) as instructors. The description presents the course as complementary to three others: it analyses shapes rather than reconstructing them, it treats triangle meshes and spectral methods, and it uses topology only as a constraint.

• Refreshers — Linear Algebra, Analysis and Optimization (spectral theorem, sparse systems, gradient descent) and Scientific Python, NumPy and PyTorch (the labs); Probability and Statistics helps for the generative chapter.
• Related courses of semester 1 — Deep Learning (the networks used from ch. 6 on), Geometric Data Analysis (kernels and distances between shapes), Topological Data Analysis for Imaging and Machine Learning, 3D Computer Vision and Medical Image Analysis Based on Generative, Geometric and Biophysical Models.
• Semester 2 courses that build on it or share its tools — Point Clouds and 3D Modelling, Geometry and Shape Spaces, Deformable Models and Geodesic Methods for Image Analysis, Graphs in Machine Learning, Generative Models for Images and Algorithms and Learning for Protein Science (learning on molecular surfaces).
• Afterwards — the Research Internship, for which the paper-implementation project is a rehearsal.

Course outline

• Review: calculus on surfaces, linear algebra and convolution — the metric, the Laplace–Beltrami operator, Green’s formula, generalised eigenproblems, a 1D finite element model, convolution and equivariance.
• Triangle meshes and discrete differential operators — meshes, hat functions, mass and stiffness matrices, the cotangent Laplacian, gradient and divergence.
• Heat diffusion, geodesics and convolution on surfaces — the heat equation, Varadhan’s formula, the heat method, and filters that act as convolutions.
• Spectral geometry, curvature and spectral signatures — manifold harmonics, mean and Gaussian curvature, Gauss–Bonnet, HKS, WKS and GPS.
• Deformation, parameterization and topology — Laplacian editing, as-rigid-as-possible deformation, Tutte and conformal maps, topological obstructions and toric covers.
• Maps between surfaces and shape matching — pointwise and functional maps, their computation from descriptors, spectral upsampling.
• Deep learning on curved surfaces — spectral and geodesic CNNs, parallel transport, holonomy, gauge-equivariant and rotation-equivariant features.
• Architectures and applications — coordinate systems, PointNet, graph networks, MeshCNN, SpiralNet++, DiffusionNet, DeltaConv; classification, segmentation, correspondence.
• Neural fields for surfaces — SDFs and occupancy, DeepSDF, occupancy networks, Fourier features, SIREN, eikonal regularisation, NeRF, implicit displacement fields.
• Generative modelling of geometry — Chamfer losses, texture synthesis and in-painting, mesh generation, differentiable meshing, Point2Mesh.
• Research directions and open problems — learned correspondence, equivariance, new neural representations and 3D generation (self-study).

Session plan

26 h in class = 8 sessions (6 × 3 h + 2 × 4 h).

The volume is the Université Paris-Saclay programme table: 12 h of lectures and 14 h of labs. master-mva.com organises the course as six lectures, each followed by a practical session (TP), with a 15-minute quiz every two lectures. The split below into eight sessions mixing lecture and lab is a proposal; the second lecture of the official list is spread over sessions 3 and 4 because it is the densest.

Level 1 = foundations, 2 = core methods, 3 = advanced methods close to research; the level never decreases from one session to the next.

Self-study, outside the 26 h (about 4 h in total): ch. 10 Research directions and open problems — learned correspondence, equivariant and discretization-agnostic networks, new neural representations, 3D generation (≈ 4 h, with Ex. 17).

How to study this module

• Read ch. 0 first even if the material looks familiar: Green’s formula and the generalised eigenproblem return in every later chapter.
• Keep one mental picture: almost everything in the course is built from two sparse matrices, the stiffness L and the mass M of ch. 1.
• After each session, run the code of the chapter and change one parameter (the diffusion time, the number of eigenfunctions, the regularisation weight) to see what breaks.
• Do the exercises listed in the session plan before the next session; the ★★★ ones are good starting points for the project.
• Python environment: NumPy, SciPy (scipy.sparse, scipy.sparse.linalg.eigsh, scipy.spatial) and PyTorch on CPU. Every code block builds its own synthetic mesh and runs in under 30 seconds on a laptop; “Code N.k” means the code of Example N.k.
• For real data, read meshes with a library such as trimesh or libigl, and inspect them in a mesh viewer such as MeshLab. Public benchmarks include FAUST (Bogo et al., 2014) and ModelNet40 (Wu et al., 2015).
• Start choosing a paper for the project around session 5: the solo subjects show the scale to aim at.

0. Review: calculus on surfaces, linear algebra and convolution

Every later chapter differentiates functions on a surface, integrates them, and solves eigenvalue problems with two matrices. This review recalls the smooth objects that the discrete operators imitate, and the linear algebra that computes them.

On a surface with boundary the formula gains a boundary term \int_{\partial S} f\, \partial_\nu h; it vanishes under Dirichlet (f = 0) or Neumann (\partial_\nu h = 0) conditions.

In practice A and B are large and sparse. Only the smallest eigenpairs are needed; they are computed by shift-invert Lanczos (scipy.sparse.linalg.eigsh with sigma). Linear systems with a sparse symmetric positive definite matrix are solved by a sparse Cholesky factorisation, computed once and reused.

import numpy as np
from scipy.linalg import eigh

n = 50                                   # interior nodes on [0, 1], u(0) = u(1) = 0
h = 1.0 / (n + 1)
K = (np.diag(2 * np.ones(n)) - np.diag(np.ones(n - 1), 1) - np.diag(np.ones(n - 1), -1)) / h
M = h / 6 * (np.diag(4 * np.ones(n)) + np.diag(np.ones(n - 1), 1) + np.diag(np.ones(n - 1), -1))
lam_consistent = eigh(K, M, eigvals_only=True)[:4]
lam_lumped = eigh(K, h * np.eye(n), eigvals_only=True)[:4]
exact = (np.pi * np.arange(1, 5)) ** 2
print("exact     ", np.round(exact, 2))
print("consistent", np.round(lam_consistent, 2))
print("lumped    ", np.round(lam_lumped, 2))

exact      [  9.87  39.48  88.83 157.91]
consistent [  9.87  39.53  89.08 158.71]
lumped     [  9.87  39.43  88.57 157.12]

1. Triangle meshes and discrete differential operators

A scanned or modelled surface reaches the computer as a list of triangles. This chapter defines functions on such a mesh and derives, with the finite element method, the discrete gradient, divergence and Laplacian that the rest of the course uses.

import numpy as np, scipy.sparse as sp
from scipy.sparse.linalg import eigsh
from scipy.spatial import ConvexHull

def sphere_mesh(n):
    """Fibonacci points on the unit sphere, triangulated by their convex hull."""
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    V = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
    F = ConvexHull(V).simplices
    nrm = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
    flip = (nrm * V[F].sum(1)).sum(1) < 0          # orient every face outwards
    F[flip] = F[flip][:, ::-1]
    return V, F

def cotan_laplacian(V, F):
    """Stiffness matrix L (positive semi-definite) of Theorem 1.6."""
    I, J, W = [], [], []
    for k in range(3):
        i, j, o = F[:, k], F[:, (k + 1) % 3], F[:, (k + 2) % 3]
        u, v = V[i] - V[o], V[j] - V[o]               # the angle at o faces edge ij
        cot = (u * v).sum(1) / np.linalg.norm(np.cross(u, v), axis=1)
        I += [i, j]; J += [j, i]; W += [cot / 2, cot / 2]
    W = sp.csr_matrix((np.concatenate(W), (np.concatenate(I), np.concatenate(J))),
                      shape=(len(V), len(V)))
    return (sp.diags(np.asarray(W.sum(1)).ravel()) - W).tocsc()

def lumped_mass(V, F):
    area = 0.5 * np.linalg.norm(np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]]), axis=1)
    return sp.diags(np.bincount(F.ravel(), np.repeat(area / 3, 3), len(V))).tocsc()

V, F = sphere_mesh(2000)
L, M = cotan_laplacian(V, F), lumped_mass(V, F)
print("faces:", len(F), " Euler characteristic:", len(V) - len(F) * 3 // 2 + len(F))
print("|L 1|_max =", abs(L @ np.ones(len(V))).max(), " area =", M.sum(), "(4 pi =", 4 * np.pi, ")")
lam = eigsh(L, k=16, M=M, sigma=-1e-6, which="LM")[0]
print(np.round(lam, 3))        # expected l(l+1): 0, 2 x3, 6 x5, 12 x7

2. Heat diffusion, geodesics and convolution on surfaces

Diffusing heat is the simplest process on a surface, and it encodes the geometry: the heat that reaches a point after a short time reveals its distance to the source. This chapter turns that remark into an algorithm for geodesic distances, and uses heat as the model of a convolution on a surface.

Taking the formula literally is a bad algorithm: the logarithm amplifies the discretisation error of a tiny kernel. Crane, Weischedel and Wardetzky (2013) keep only the direction of the gradient of the heat, which is accurate, and recover the magnitude from the eikonal equation.

import numpy as np, scipy.sparse as sp
from scipy.sparse.linalg import splu
from scipy.spatial import ConvexHull

def sphere_mesh(n):
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    V = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
    F = ConvexHull(V).simplices
    nrm = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
    flip = (nrm * V[F].sum(1)).sum(1) < 0
    F[flip] = F[flip][:, ::-1]
    return V, F

def hat_gradients(V, F):
    """Per face: area, unit normal, and the gradients of the three hat functions."""
    N = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
    A = 0.5 * np.linalg.norm(N, axis=1); N = N / (2 * A[:, None])
    G = [np.cross(N, V[F[:, (k + 2) % 3]] - V[F[:, (k + 1) % 3]]) / (2 * A[:, None]) for k in range(3)]
    return A, N, G

def heat_geodesic(V, F, src, c=1.0):
    n = len(V)
    A, N, G = hat_gradients(V, F)
    rows = np.concatenate([F[:, a] for a in range(3) for b in range(3)])
    cols = np.concatenate([F[:, b] for a in range(3) for b in range(3)])
    vals = np.concatenate([A * (G[a] * G[b]).sum(1) for a in range(3) for b in range(3)])
    L = sp.csc_matrix((vals, (rows, cols)), shape=(n, n))         # stiffness = cotan matrix
    M = sp.diags(np.bincount(F.ravel(), np.repeat(A / 3, 3), n)).tocsc()
    h = np.linalg.norm(V[F[:, 0]] - V[F[:, 1]], axis=1).mean()
    u0 = np.zeros(n); u0[src] = 1.0
    u = splu((M + c * h ** 2 * L).tocsc()).solve(M @ u0)           # step 1: heat flow
    gu = sum(u[F[:, k], None] * G[k] for k in range(3))
    X = -gu / np.linalg.norm(gu, axis=1, keepdims=True)              # step 2: normalise
    b = np.zeros(n)
    for k in range(3):                                                # step 3: Poisson
        np.add.at(b, F[:, k], A * (X * G[k]).sum(1))
    phi = splu((L + 1e-10 * sp.eye(n)).tocsc()).solve(b)
    return phi - phi[src]

V, F = sphere_mesh(4000)
src = 0
exact = np.arccos(np.clip(V @ V[src], -1, 1))
for c in [0.1, 1.0, 10.0]:
    d = heat_geodesic(V, F, src, c)
    print(f"t = {c:4} h^2: mean |error| = {np.abs(d - exact).mean():.4f}, "
          f"max = {np.abs(d - exact).max():.4f} (diameter pi)")

The heat kernel acts on a function like a Gaussian blur of width about \sqrt{2t}. This suggests what a convolution on a surface can be.

3. Spectral geometry, curvature and spectral signatures

Laplacian eigenfunctions are the Fourier basis of a surface, and curvature measures how it departs from a plane. This chapter computes both and combines them into descriptors that survive bending.

On a smooth surface the coordinate map x satisfies \Delta x = -2H n. The discrete counterpart is an exact statement about areas.

import numpy as np, scipy.sparse as sp
from scipy.sparse.linalg import eigsh
from scipy.spatial import ConvexHull

def sphere_mesh(n):
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    V = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
    F = ConvexHull(V).simplices
    nrm = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
    flip = (nrm * V[F].sum(1)).sum(1) < 0
    F[flip] = F[flip][:, ::-1]
    return V, F

def operators(V, F):
    """Cotan stiffness L, lumped mass M, and the angle defect at each vertex."""
    n = len(V); I, J, W = [], [], []; angle_sum = np.zeros(n)
    for k in range(3):
        i, j, o = F[:, k], F[:, (k + 1) % 3], F[:, (k + 2) % 3]
        u, v = V[i] - V[o], V[j] - V[o]
        cos_, sin_ = (u * v).sum(1), np.linalg.norm(np.cross(u, v), axis=1)
        I += [i, j]; J += [j, i]; W += [cos_ / sin_ / 2] * 2
        np.add.at(angle_sum, o, np.arctan2(sin_, cos_))       # interior angle at o
    W = sp.csr_matrix((np.concatenate(W), (np.concatenate(I), np.concatenate(J))), shape=(n, n))
    L = (sp.diags(np.asarray(W.sum(1)).ravel()) - W).tocsc()
    area = 0.5 * np.linalg.norm(np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]]), axis=1)
    mass = np.bincount(F.ravel(), np.repeat(area / 3, 3), n)
    return L, sp.diags(mass).tocsc(), mass, 2 * np.pi - angle_sum

V, F = sphere_mesh(2000)
V = V * np.array([2.0, 1.0, 1.0])                         # prolate spheroid, semi-axes 2, 1, 1
L, M, mass, defect = operators(V, F)
K = defect / mass                                          # Gaussian curvature per unit area
H = np.linalg.norm((L @ V) / mass[:, None], axis=1) / 2   # |Delta x| / 2 = |H|
tip, eq = np.argmax(V[:, 0]), np.argmin(np.abs(V[:, 0]) + np.abs(V[:, 2]))
print(f"sum of angle defects = {defect.sum():.6f}   (2 pi chi = {4 * np.pi:.6f})")
print(f"tip:     K = {K[tip]:.2f} (exact 4),    H = {H[tip]:.2f} (exact 2)")
print(f"equator: K = {K[eq]:.2f} (exact 0.25), H = {H[eq]:.3f} (exact 0.625)")

lam, phi = eigsh(L, k=80, M=M, sigma=-1e-6, which="LM")
for t in [0.1, 1.0]:
    hks = (np.exp(-lam * t) * phi ** 2).sum(1)              # Definition 3.9
    print(f"HKS(t = {t}): tip {hks[tip]:.3f}, equator {hks[eq]:.3f};",
          f"1/(4 pi t) + K/(12 pi): {1 / (4 * np.pi * t) + 4 / (12 * np.pi):.3f},",
          f"{1 / (4 * np.pi * t) + 0.25 / (12 * np.pi):.3f}")
for k in [1, 4, 16, 80]:                                     # Example 3.4: spectral smoothing
    Vk = phi[:, :k] @ (phi[:, :k].T @ (mass[:, None] * V))
    print(f"k = {k:2d}: mean |x - x_k| = {np.linalg.norm(V - Vk, axis=1).mean():.4f}")

4. Deformation, parameterization and topology

Editing a shape and flattening it onto the plane both minimise geometric energies built from the operators of ch. 1. Topology decides what flattening can achieve.

Flattening asks how much distortion is unavoidable; topology answers part of the question.

import numpy as np, scipy.sparse as sp
from scipy.sparse.linalg import spsolve
from scipy.spatial import ConvexHull

def sphere_mesh(n):
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    V = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
    F = ConvexHull(V).simplices
    nrm = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
    flip = (nrm * V[F].sum(1)).sum(1) < 0
    F[flip] = F[flip][:, ::-1]
    return V, F

V, F = sphere_mesh(1500)
F = F[(V[F, 2] > -0.3).all(1)]                       # a disk: the sphere minus a polar cap
used = np.unique(F); remap = -np.ones(len(V), int); remap[used] = np.arange(len(used))
V, F = V[used], remap[F]
n = len(V)

# boundary edges appear in a single face; chain them into a loop
E = np.concatenate([F[:, [0, 1]], F[:, [1, 2]], F[:, [2, 0]]])
key = {tuple(e) for e in E}
nxt = {a: b for a, b in E if (b, a) not in key}
loop = [next(iter(nxt))]
while nxt[loop[-1]] != loop[0]:
    loop.append(nxt[loop[-1]])
seg = np.linalg.norm(V[loop] - V[np.roll(loop, -1)], axis=1)
ang = 2 * np.pi * np.r_[0, np.cumsum(seg)[:-1]] / seg.sum()
U_b = np.c_[np.cos(ang), np.sin(ang)]                 # boundary pinned to the unit circle

def weights(kind):
    I, J, W = [], [], []
    for k in range(3):
        i, j, o = F[:, k], F[:, (k + 1) % 3], F[:, (k + 2) % 3]
        u, v = V[i] - V[o], V[j] - V[o]
        w = np.ones(len(F)) if kind == "uniform" else \
            (u * v).sum(1) / np.linalg.norm(np.cross(u, v), axis=1) / 2
        I += [i, j]; J += [j, i]; W += [w, w]
    Wm = sp.csr_matrix((np.concatenate(W), (np.concatenate(I), np.concatenate(J))), shape=(n, n))
    if kind == "uniform":
        Wm.data[:] = 1.0                              # each edge counted once
    return (sp.diags(np.asarray(Wm.sum(1)).ravel()) - Wm).tocsr()

inner = np.setdiff1d(np.arange(n), loop)
for kind in ["uniform", "cotan"]:
    L = weights(kind)
    U = np.zeros((n, 2)); U[loop] = U_b
    rhs = -L[inner][:, loop] @ U_b
    U[inner] = np.c_[spsolve(L[inner][:, inner].tocsc(), rhs[:, 0]),
                     spsolve(L[inner][:, inner].tocsc(), rhs[:, 1])]
    e1, e2 = U[F[:, 1]] - U[F[:, 0]], U[F[:, 2]] - U[F[:, 0]]
    signed = 0.5 * (e1[:, 0] * e2[:, 1] - e1[:, 1] * e2[:, 0])
    p1, p2 = V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]]
    x = p1 / np.linalg.norm(p1, axis=1, keepdims=True)           # local frame of each 3D face
    y = p2 - (p2 * x).sum(1, keepdims=True) * x; y /= np.linalg.norm(y, axis=1, keepdims=True)
    P = np.stack([np.c_[(p1 * x).sum(1), (p1 * y).sum(1)], np.c_[(p2 * x).sum(1), (p2 * y).sum(1)]], 2)
    Q = np.stack([e1, e2], 2)                                      # columns = 2D edges
    s = np.linalg.svd(Q @ np.linalg.inv(P), compute_uv=False)      # singular values of the Jacobian
    print(f"{kind:8s}: flipped = {(signed <= 0).sum()}, mean sigma1/sigma2 = {(s[:, 0] / s[:, 1]).mean():.3f}")

5. Maps between surfaces and shape matching

Matching two shapes means finding, for each point of one, the corresponding point of the other: the same fingertip on a body in two poses. A point-to-point map is a hard combinatorial object; this chapter replaces it with a small matrix acting on functions, computed by linear algebra.

import numpy as np, scipy.sparse as sp
from scipy.sparse.linalg import eigsh
from scipy.spatial import ConvexHull, cKDTree

def bumpy(n, R):
    """Fibonacci directions rotated by R, triangulated, then pushed to radius r(d)."""
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    D = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)] @ R.T
    F = ConvexHull(D).simplices
    r = 1 + 0.25 * np.sin(3 * D[:, 0] + 1) * np.cos(2 * D[:, 1] + 0.5) + 0.2 * D[:, 2] ** 3
    return D * r[:, None], F, D

def eig(V, F, k):
    n = len(V); I, J, W = [], [], []
    for a in range(3):
        i, j, o = F[:, a], F[:, (a + 1) % 3], F[:, (a + 2) % 3]
        u, v = V[i] - V[o], V[j] - V[o]
        c = (u * v).sum(1) / np.linalg.norm(np.cross(u, v), axis=1) / 2
        I += [i, j]; J += [j, i]; W += [c, c]
    W = sp.csr_matrix((np.concatenate(W), (np.concatenate(I), np.concatenate(J))), shape=(n, n))
    L = sp.diags(np.asarray(W.sum(1)).ravel()) - W
    area = 0.5 * np.linalg.norm(np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]]), axis=1)
    m = np.bincount(F.ravel(), np.repeat(area / 3, 3), n)
    lam, phi = eigsh(L.tocsc(), k=k, M=sp.diags(m).tocsc(), sigma=-1e-6, which="LM")
    return lam, phi, m

def wks(lam, phi, q=40):
    """Wave kernel signature (Definition 3.10) at q log-spaced energies."""
    loglam = np.log(np.maximum(lam[1:], 1e-8))
    e = np.linspace(loglam.min(), loglam.max(), q); s = 7 * (e[1] - e[0])
    w = np.exp(-(e[None, :] - loglam[:, None]) ** 2 / (2 * s ** 2))
    return (phi[:, 1:] ** 2) @ w / w.sum(0)

rng = np.random.default_rng(0)
Rb, _ = np.linalg.qr(rng.normal(size=(3, 3)))
VA, FA, DA = bumpy(1200, np.eye(3))                # shape M
VB, FB, DB = bumpy(1500, Rb)                       # shape N: same surface, another sampling
lA, PA, mA = eig(VA, FA, 40); lB, PB, mB = eig(VB, FB, 40)
k = 20
gA = (PA[:, :k].T * mA) @ wks(lA, PA); gB = (PB[:, :k].T * mB) @ wks(lB, PB)
alpha = 1e-2 * np.linalg.norm(gA) ** 2 / np.linalg.norm(lA[:k]) ** 2
C = np.zeros((k, k))
for i in range(k):                                 # row-wise closed form (Proposition 5.5)
    C[i] = np.linalg.solve(gB @ gB.T + alpha * np.diag((lA[i] - lB[:k]) ** 2), gB @ gA[i])

truth = cKDTree(DB).query(DA)[1]                   # ground truth through the directions
def error(T):                                      # mean distance, in units of sqrt(area)
    return np.linalg.norm(VB[T] - VB[truth], axis=1).mean() / np.sqrt(mB.sum())

T = cKDTree(PB[:, :k] @ C.T).query(PA[:, :k])[1]  # Phi_N(T(x)) C^T ~ Phi_M(x)
print(f"random map: {error(rng.integers(0, len(VB), len(VA))):.3f}")
print(f"functional map, k = {k}: {error(T):.4f}, exact hits {np.mean(T == truth):.0%}")
print("diagonal of C (first 8):", np.round(np.diag(C)[:8], 2))

6. Deep learning on curved surfaces

A convolutional network slides one filter over a grid, using translations and a fixed “up”. A curved surface has neither. This chapter builds surface convolutions from the spectrum, from local charts and from parallel transport.

To compare directional features at neighbouring points, a network must move tangent vectors between tangent planes: parallel transport.

import numpy as np
from scipy.spatial import ConvexHull

rng = np.random.default_rng(1)
n = 400
i = np.arange(n) + 0.5
phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
D = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
F = ConvexHull(D).simplices
flip = (np.cross(D[F[:, 1]] - D[F[:, 0]], D[F[:, 2]] - D[F[:, 0]]) * D[F].sum(1)).sum(1) < 0
F[flip] = F[flip][:, ::-1]                                     # outward orientation
V = D * (1 + 0.2 * np.sin(3 * D[:, :1]) * D[:, 1:2])          # a bumpy sphere

N = np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]])
N /= np.linalg.norm(N, axis=1, keepdims=True)
X = V[F[:, 1]] - V[F[:, 0]]; X /= np.linalg.norm(X, axis=1, keepdims=True)
Y = np.cross(N, X)                                             # face frames (X, Y): the gauge

owner = {(t[k], t[(k + 1) % 3]): f for f, t in enumerate(F) for k in range(3)}
rho = {}                                                        # transport angle from face g to face f
for (a, b), f in owner.items():
    g, d = owner[(b, a)], V[b] - V[a]
    rho[(g, f)] = np.arctan2(d @ Y[f], d @ X[f]) - np.arctan2(d @ Y[g], d @ X[g])

angle_sum = np.zeros(len(V))
for k in range(3):
    p, q = V[F[:, (k + 1) % 3]] - V[F[:, k]], V[F[:, (k + 2) % 3]] - V[F[:, k]]
    np.add.at(angle_sum, F[:, k], np.arctan2(np.linalg.norm(np.cross(p, q), axis=1), (p * q).sum(1)))

first_face = {v: f for f, t in enumerate(F) for v in t}
gap = 0.0
for v, f0 in first_face.items():                                # walk once around each vertex
    f, hol = f0, 0.0
    while True:
        t = list(F[f]); g = owner[(v, t[(t.index(v) + 2) % 3])]
        hol += rho[(f, g)]; f = g
        if f == f0:
            break
    d = hol - (2 * np.pi - angle_sum[v])
    gap = max(gap, abs((d + np.pi) % (2 * np.pi) - np.pi))
print(f"max |holonomy - angle defect| over {len(V)} vertices: {gap:.1e}")

z = rng.normal(size=len(F)) + 1j * rng.normal(size=len(F))    # one tangent vector per face
def layer(z, rho, transport=True):
    out = 0.5 * z.copy()
    for (g, f), r in rho.items():
        out[f] += 0.3 * (np.exp(1j * r) if transport else 1.0) * z[g]
    return out
gauge = rng.uniform(0, 2 * np.pi, len(F))                      # rotate every face frame
z2 = np.exp(-1j * gauge) * z
rho2 = {(g, f): r - gauge[f] + gauge[g] for (g, f), r in rho.items()}
for transport in [True, False]:
    err = np.abs(layer(z2, rho2, transport) - np.exp(-1j * gauge) * layer(z, rho, transport)).max()
    print(f"transport = {transport}: equivariance gap {err:.1e}")

7. Architectures and applications: from PointNet to DiffusionNet

Architectures for 3D shapes differ by the representation they consume and the invariances they build in. This chapter compares them and trains a small operator-based network.

PointNet sees each point alone before the maximum; local structure requires neighbourhoods.

import numpy as np, scipy.sparse as sp, torch
from scipy.sparse.linalg import eigsh
from scipy.spatial import ConvexHull

def bumpy_mesh(n, k=48):
    """Bumpy sphere with n vertices, its first k Laplace-Beltrami eigenpairs and its masses."""
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    D = np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]
    F = ConvexHull(D).simplices
    V = D * (1 + 0.25 * np.sin(3 * D[:, :1] + 1) * np.cos(2 * D[:, 1:2] + 0.5))
    I, J, W = [], [], []
    for a in range(3):
        p, q, o = F[:, a], F[:, (a + 1) % 3], F[:, (a + 2) % 3]
        u, v = V[p] - V[o], V[q] - V[o]
        c = (u * v).sum(1) / np.linalg.norm(np.cross(u, v), axis=1) / 2
        I += [p, q]; J += [q, p]; W += [c, c]
    W = sp.csr_matrix((np.concatenate(W), (np.concatenate(I), np.concatenate(J))), shape=(n, n))
    L = sp.diags(np.asarray(W.sum(1)).ravel()) - W
    area = 0.5 * np.linalg.norm(np.cross(V[F[:, 1]] - V[F[:, 0]], V[F[:, 2]] - V[F[:, 0]]), axis=1)
    m = np.bincount(F.ravel(), np.repeat(area / 3, 3), n)
    lam, Phi = eigsh(L.tocsc(), k=k, M=sp.diags(m).tocsc(), sigma=-1e-6, which="LM")
    label = (D[:, 0] > 0.3 * np.sin(3 * D[:, 1])).astype(int) + 2 * (D[:, 2] > 0.2)
    as_t = lambda x: torch.tensor(x, dtype=torch.float32)
    return as_t(lam), as_t(Phi), as_t(m), torch.tensor(label)

class DiffusionBlock(torch.nn.Module):
    """Learned diffusion (one time per channel), then a pointwise MLP, with a residual."""
    def __init__(self, c):
        super().__init__()
        self.log_t = torch.nn.Parameter(torch.full((c,), -3.0))
        self.mlp = torch.nn.Sequential(torch.nn.Linear(2 * c, c), torch.nn.ReLU(), torch.nn.Linear(c, c))
    def forward(self, x, lam, Phi, m):
        coef = Phi.T @ (m[:, None] * x)                            # spectral coefficients
        x_diff = Phi @ (torch.exp(-lam[:, None] * self.log_t.exp()[None, :]) * coef)
        return x + self.mlp(torch.cat([x, x_diff], 1))

class MiniDiffusionNet(torch.nn.Module):
    def __init__(self, c_in=4, width=32, c_out=4, blocks=2):
        super().__init__()
        self.inp, self.out = torch.nn.Linear(c_in, width), torch.nn.Linear(width, c_out)
        self.blocks = torch.nn.ModuleList(DiffusionBlock(width) for _ in range(blocks))
    def forward(self, x, lam, Phi, m):
        x = self.inp(x)
        for b in self.blocks:
            x = b(x, lam, Phi, m)
        return self.out(x)

def noisy_input(label, p, gen):
    flip = torch.rand(len(label), generator=gen) < p
    noisy = torch.where(flip, torch.randint(0, 4, (len(label),), generator=gen), label)
    return torch.nn.functional.one_hot(noisy, 4).float()

torch.set_num_threads(1)                    # small tensors: one thread is fastest
torch.manual_seed(0); gen = torch.Generator().manual_seed(0)
train, test = bumpy_mesh(800), bumpy_mesh(2500)                 # two discretisations
net = MiniDiffusionNet(); opt = torch.optim.Adam(net.parameters(), lr=1e-2)
for step in range(300):
    x = noisy_input(train[3], 0.5, gen)
    loss = torch.nn.functional.cross_entropy(net(x, *train[:3]), train[3])
    opt.zero_grad(); loss.backward(); opt.step()
with torch.no_grad():
    x = noisy_input(test[3], 0.5, gen)
    acc = (net(x, *test[:3]).argmax(1) == test[3]).float().mean()
    print(f"input accuracy {(x.argmax(1) == test[3]).float().mean():.2f}, "
          f"output accuracy on the unseen 2500-vertex mesh {acc:.3f}")
    print("learned diffusion times:", [f"{b.log_t.exp().mean():.3f}" for b in net.blocks])

8. Neural fields for surfaces

A mesh fixes a resolution and a topology. A neural field represents a surface as the zero set of a small network, queried anywhere. This chapter defines such fields, explains why plain networks miss detail, and regularises and renders them.

Fitting a field with a plain ReLU network fails in a specific way: the network learns low frequencies first and fine details very slowly. This spectral bias is fixed by changing the input.

import numpy as np, torch
torch.set_num_threads(1); torch.manual_seed(0)

f = lambda x: torch.sin(2 * np.pi * x) + 0.5 * torch.sin(2 * np.pi * 12 * x)
x_train, x_test = torch.rand(256, 1), torch.linspace(0, 1, 1000)[:, None]

class FourierFeatures(torch.nn.Module):          # gamma(x) = [cos 2 pi Bx, sin 2 pi Bx]
    def __init__(self, m=64, sigma=10.0):
        super().__init__(); self.register_buffer("B", sigma * torch.randn(1, m))
    def forward(self, x):
        return torch.cat([torch.cos(2 * np.pi * x @ self.B), torch.sin(2 * np.pi * x @ self.B)], 1)

class Sine(torch.nn.Module):                     # SIREN layer, omega_0 = 30
    def __init__(self, d_in, d_out, first=False, w0=30.0):
        super().__init__(); self.w0, self.lin = w0, torch.nn.Linear(d_in, d_out)
        bound = 1 / d_in if first else np.sqrt(6 / d_in) / w0
        torch.nn.init.uniform_(self.lin.weight, -bound, bound)
    def forward(self, x):
        return torch.sin(self.w0 * self.lin(x))

relu_mlp = lambda d_in: [torch.nn.Linear(d_in, 128), torch.nn.ReLU(), torch.nn.Linear(128, 128),
                         torch.nn.ReLU(), torch.nn.Linear(128, 1)]
models = {"ReLU MLP": torch.nn.Sequential(*relu_mlp(1)),
          "Fourier features + ReLU": torch.nn.Sequential(FourierFeatures(), *relu_mlp(128)),
          "SIREN": torch.nn.Sequential(Sine(1, 128, first=True), Sine(128, 128), torch.nn.Linear(128, 1))}
for name, net in models.items():
    opt = torch.optim.Adam(net.parameters(), lr=1e-3)
    for step in range(1000):
        loss = ((net(x_train) - f(x_train)) ** 2).mean()
        opt.zero_grad(); loss.backward(); opt.step()
    with torch.no_grad():
        print(f"{name:24s} train MSE {loss.item():.4f}   test MSE {((net(x_test) - f(x_test)) ** 2).mean():.4f}")

import numpy as np, torch
torch.set_num_threads(1); torch.manual_seed(0)

theta = torch.rand(512) * 2 * np.pi                   # samples of the curve r = 1 + 0.3 cos 5 theta
r = 1 + 0.3 * torch.cos(5 * theta)
pts = torch.stack([r * torch.cos(theta), r * torch.sin(theta)], 1)
dense_t = torch.linspace(0, 2 * np.pi, 4000)           # dense copy, only to measure errors
dense_r = 1 + 0.3 * torch.cos(5 * dense_t)
dense = torch.stack([dense_r * torch.cos(dense_t), dense_r * torch.sin(dense_t)], 1)

def true_sdf(x):                                       # sign: inside the curve is negative
    dist = torch.cdist(x, dense).min(1).values
    ang = torch.atan2(x[:, 1], x[:, 0])
    return torch.where(x.norm(dim=1) < 1 + 0.3 * torch.cos(5 * ang), -dist, dist)

net = torch.nn.Sequential(torch.nn.Linear(2, 64), torch.nn.Softplus(beta=100),
                          torch.nn.Linear(64, 64), torch.nn.Softplus(beta=100),
                          torch.nn.Linear(64, 64), torch.nn.Softplus(beta=100),
                          torch.nn.Linear(64, 1))
with torch.no_grad():                                  # start near the SDF of a disc
    net[-1].bias.fill_(-1.0)

def grad(x):
    x = x.requires_grad_(True)
    y = net(x)
    return y, torch.autograd.grad(y.sum(), x, create_graph=True)[0]

opt = torch.optim.Adam(net.parameters(), lr=2e-3)
for step in range(600):
    free = torch.rand(256, 2) * 3.2 - 1.6              # points of the box [-1.6, 1.6]^2
    _, g = grad(free)
    loss = net(pts).abs().mean() + 0.1 * ((g.norm(dim=1) - 1) ** 2).mean()   # data + eikonal
    opt.zero_grad(); loss.backward(); opt.step()

test = torch.rand(4000, 2) * 3.2 - 1.6
f_test, g_test = grad(test)
print(f"mean |f| on the curve:        {net(dense).abs().mean().item():.4f}")
print(f"mean ||grad f|| - 1| in box:  {(g_test.norm(dim=1) - 1).abs().mean().item():.4f}")
print(f"mean |f - true SDF| in box:   {(f_test[:, 0] - true_sdf(test)).abs().mean().item():.4f}")

9. Generative modelling of geometry

The last step is to produce geometry rather than analyse it: add detail to a surface, fill a hole, create a mesh, or fit a surface to raw points. This chapter covers the losses, the generators and the differentiable meshing steps that make this possible.

The other road generates an implicit field and extracts its surface. Marching cubes is not differentiable as a whole, since the topology changes discontinuously, but the vertex positions are.

import numpy as np, torch
from scipy.spatial import ConvexHull
torch.set_num_threads(1); torch.manual_seed(0); rng = np.random.default_rng(0)

def fib(n):
    i = np.arange(n) + 0.5
    phi, th = np.arccos(1 - 2 * i / n), np.pi * (1 + 5 ** 0.5) * i
    return np.c_[np.cos(th) * np.sin(phi), np.sin(th) * np.sin(phi), np.cos(phi)]

# target: 1500 noisy points on an elongated, bumpy surface (no mesh, no normals)
d = rng.normal(size=(1500, 3)); d /= np.linalg.norm(d, axis=1, keepdims=True)
r = 0.8 + 0.6 * d[:, 0] ** 2 + 0.15 * np.sin(4 * d[:, 1]) * d[:, 2]
target = torch.tensor(d * r[:, None] + 0.005 * rng.normal(size=d.shape), dtype=torch.float32)

D = fib(642); F = ConvexHull(D).simplices                     # template: a sphere of radius 1.2
V0 = torch.tensor(1.2 * D, dtype=torch.float32)
E = np.unique(np.sort(np.concatenate([F[:, [0, 1]], F[:, [1, 2]], F[:, [2, 0]]]), 1), axis=0)
i, j = torch.tensor(E[:, 0]), torch.tensor(E[:, 1])
deg = torch.bincount(torch.cat([i, j]), minlength=len(D))[:, None].float()

def umbrella(V):                                                # uniform Laplacian (I - D^-1 A) V
    s = torch.zeros_like(V).index_add(0, i, V[j]).index_add(0, j, V[i])
    return V - s / deg

def chamfer(P, Q):
    d2 = (P * P).sum(1)[:, None] - 2 * P @ Q.T + (Q * Q).sum(1)[None, :]   # squared distances
    return d2.min(1).values.mean() + d2.min(0).values.mean()

for lam in [0.0, 1.0]:
    offset = torch.zeros_like(V0, requires_grad=True)
    opt = torch.optim.Adam([offset], lr=1e-2)
    for step in range(250):
        V = V0 + offset
        loss = chamfer(V, target) + lam * (umbrella(V) ** 2).sum(1).mean()
        opt.zero_grad(); loss.backward(); opt.step()
    V = (V0 + offset).detach()
    e = V[E[:, 0]] - V[E[:, 1]]
    print(f"lambda = {lam}: Chamfer {chamfer(V0, target):.4f} -> {chamfer(V, target):.5f}, "
          f"edge length max/mean {e.norm(dim=1).max() / e.norm(dim=1).mean():.1f}")

10. Research directions and open problems

This chapter is for self-study. It points to active lines of work that extend the course, with papers that can serve as starting points for the project or the internship. Each paragraph names the question, a few representative works, and what remains open.

Learned correspondence

Deep functional maps (Litany et al., 2017) learn the descriptors that feed the solve of Proposition 5.5, so that the whole pipeline of ch. 5 trains end to end. Later work removes the need for ground-truth maps by penalising violations of the structure of Theorem 5.3: orthogonality, commutativity with the Laplacians, and bijectivity.

Work by Cao, Roetzer and Bernard (2023) learns spectral matching without labels and makes it robust to noise and partiality. Attaiki and Ovsjanikov (2023) analyse which properties of learned features make the pointwise map consistent with the functional map, and use this analysis to improve training.

Open problems remain hard: partial shapes, strongly non-isometric pairs (a cat and a horse), and topological noise such as touching hands, which breaks the intrinsic metric.

Discretisation-agnostic and equivariant networks

DiffusionNet (Definition 7.6) showed that networks built from converging operators transfer across meshes and point clouds. The operators themselves keep improving. Sharp and Crane (2020) define a Laplacian for nonmanifold meshes and point clouds through a “tufted” intrinsic Delaunay cover; Sharp, Soliman and Crane (2019) compute parallel transport and logarithmic maps by diffusing vectors (the vector heat method).

Equivariance is the other axis. Gauge-equivariant convolutions (Cohen et al., 2019; de Haan et al., 2021) generalise Proposition 6.9 to general filters, and Vector Neurons (Deng et al., 2021) make point networks equivariant to 3D rotations by using vector-valued neurons.

The open question is the price of these constraints: equivariant layers are more expensive and sometimes less expressive than augmented ones, and the best trade-off depends on the amount of data.

New neural representations

Coordinate networks are slow to evaluate. Multiresolution hash encodings (Müller et al., 2022) replace most of the network by trainable grids and make fitting fast. VolSDF (Yariv et al., 2021) and NeuS (Wang et al., 2021) render an SDF through a density derived from it, so that photographs supervise a clean surface rather than a cloud of density.

3D Gaussian splatting (Kerbl et al., 2023) represents a scene by explicit anisotropic Gaussians rendered by rasterisation, with real-time quality. Extracting a watertight, manifold surface from such representations, with guarantees, is an open problem at the meeting point of ch. 8 and ch. 1.

Generating 3D shapes

Diffusion models generate point clouds by denoising (Luo and Hu, 2021). DreamFusion (Poole et al., 2023) optimises a radiance field so that its renderings score well under a pre-trained 2D text-to-image diffusion model. Transformers such as MeshGPT (Siddiqui et al., 2024) generate meshes as artists make them, with few, well-placed triangles.

The open problems are the scarcity of 3D data compared with images, the control of topology and of validity (no self-intersection, manifoldness), and evaluation: Chamfer distances and their relatives measure fidelity poorly.

A short list of open questions

• Can a map between non-isometric shapes be learned with guarantees of continuity and bijectivity?
• Which operator-based architecture is universal on surfaces, in the way PointNet is on sets (Theorem 7.2)?
• How should meshes, point clouds and neural fields be handled by one network, without converting between them?
• What explains the generalisation of a neural field between its training points, beyond the kernel picture of Theorem 8.3?

Exercises

1. ★ The cotangent Laplacian on the equilateral lattice. Tile the plane with equilateral triangles of side h. Compute the row of L at a vertex and its lumped mass, and check that -M^{-1} L is exact on u(x, y) = x^2.

   Solution: every edge faces two angles of 60^\circ, so its weight is \frac12 \cdot 2 \cot 60^\circ = 1/\sqrt3 \approx 0.577. The vertex has six neighbours, so L_{ii} = 6/\sqrt3 \approx 3.464.

   Six triangles of area \frac{\sqrt3}{4} h^2 give M_{ii} = \frac{\sqrt3}{2} h^2. Hence (M^{-1} L u)_i = \frac{2}{3h^2} \sum_{j \sim i} (u_i - u_j).

   The neighbours of x_i have abscissas x_i + h \cos(k\pi/3), k = 0, \dots, 5, so \sum_j (u_j - u_i) = \sum_{k=0}^{5} \Big( 2 x_i h \cos\frac{k\pi}{3} + h^2 \cos^2 \frac{k\pi}{3} \Big) = 3h^2 .

   Then (M^{-1}Lu)_i = -2 = -\Delta u, exactly.

2. ★ The mass matrix of one triangle. The barycentric coordinates \lambda_1, \lambda_2, \lambda_3 of a triangle T of area A satisfy \int_T \lambda_1^a \lambda_2^b \lambda_3^c \,\mathrm{d}A = 2A\, \frac{a!\, b!\, c!}{(a + b + c + 2)!}.

   Compute the local mass matrix, its eigenvalues, and its row sums.

   Solution: \int \psi_i^2 = 2A \cdot 2/24 = A/6 and \int \psi_i \psi_j = 2A/24 = A/12, so the block is \frac{A}{12}(1 + \delta_{ij}).

   Its eigenvalues are A/3 (on the constant vector) and A/12 twice. Each row sums to A/6 + 2 \cdot A/12 = A/3, the lumped mass of Definition 1.3.

3. ★ Counting with the Euler characteristic. (a) A closed mesh of genus 2 has 1000 vertices: how many edges and triangles? (b) A torus is meshed as an n \times m periodic grid of squares, each cut into two triangles: check that \chi = 0. (c) Express the average vertex degree in terms of \chi and |V|.

   Solution:

   • (a) \chi = 2 - 2g = -2, so |F| = 2|V| - 2\chi = 2004 and |E| = 3|V| - 3\chi = 3006 (Proposition 1.2).
   • (b) |V| = nm, |E| = 3nm (two sides and one diagonal per square), |F| = 2nm, so \chi = 0.
   • (c) The average degree is 2|E|/|V| = 6 - 6\chi/|V|.

4. ★ Angle defects of polyhedra. Compute the angle defects of the regular tetrahedron, the octahedron and the cube (with each square cut into two triangles), and check Theorem 3.8.

   Solution:

   • Tetrahedron: three angles of \pi/3 per vertex, defect \pi, total 4\pi.
   • Octahedron: four angles of \pi/3, defect 2\pi/3, total 6 \cdot 2\pi/3 = 4\pi.
   • Cube: the angles at a corner sum to 3\pi/2 whatever the diagonals, defect \pi/2, total 8 \cdot \pi/2 = 4\pi.

   All three give 2\pi\chi with \chi = 2.

5. ★ The HKS of the round sphere. Using the multiplicities of Example 0.4 and the addition theorem \sum_m Y_{\ell m}(x)^2 = (2\ell + 1)/(4\pi), compute \mathrm{HKS}(x, t) on the unit sphere. Why is it constant? Compare its value at t = 0.1 with the expansion of Definition 3.9.

   Solution: the signature does not depend on x: \mathrm{HKS}(x, t) = \sum_{\ell \geq 0} \frac{2\ell + 1}{4\pi}\, e^{-\ell(\ell + 1) t}.

   Rotations act transitively on the sphere and preserve every intrinsic quantity, so no intrinsic descriptor can distinguish points. At t = 0.1 the series gives 0.8228, and \frac{1}{4\pi t} + \frac{K}{12\pi} = 0.8223 with K = 1.

6. ★ Volume rendering by hand. A ray crosses three samples with spacing \delta = 0.5, densities \sigma = (0, 2, 4) and grey levels c = (1, 0.5, 0). Compute the weights T_i(1 - e^{-\sigma_i \delta}), the rendered value and the transmittance left for the background (Definition 8.8).

   Solution:

   • T_1 = 1 and the first weight is 0 (empty space).
   • T_2 = 1 and the second weight is 1 - e^{-1} = 0.632.
   • T_3 = e^{-1} = 0.368 and the third weight is 0.368 (1 - e^{-2}) = 0.318.

   The rendered value is 0.632 \cdot 0.5 = 0.316, and the background still receives e^{-3} = 0.050.

7. ★★ Obtuse angles and the maximum principle. (a) Two triangles share the edge ij and both have an angle of 100^\circ opposite to it: compute the weight of ij. (b) Show that L is still positive semi-definite. (c) Explain why the heat flow of Proposition 2.2 may now create negative temperatures, and how an intrinsic Delaunay triangulation (Bobenko and Springborn, 2007) avoids it.

   Solution:

   • (a) \cot 100^\circ \approx -0.176, so the weight is -0.176 and L_{ij} > 0.
   • (b) u^\top L u = \int \|\nabla u\|^2 \geq 0 for every mesh (Proposition 1.7).
   • (c) M + tL is no longer a Z-matrix, so its inverse can have negative entries: heat at j lowers the temperature at i. An intrinsic Delaunay triangulation flips edges in the intrinsic metric until \alpha + \beta \leq \pi everywhere, without moving the surface.

8. ★★ The heat method on a flat square (computational). Mesh [0, 1]^2 with a 41 \times 41 grid, each square cut along the same diagonal (Example 1.9), and put the source at (0.25, 0.25). Run Algorithm 2.5 for t = c h^2, with h = 1/40 the grid step and c \in \{0.1, 1, 10, 100\}, against the Euclidean distance.

   Then replace the heat u by the average of the Neumann solution and the Dirichlet solution (u = 0 on the boundary), as Crane et al. (2013) recommend.

   Hints and expected result: the mean errors with the natural (Neumann) boundary condition are about 0.045, 0.006, 0.020 and 0.057. With the averaged condition they are 0.047, 0.010, 0.003 and 0.014. A small t is noisy; a large t lets the boundary bend the isolines, and the averaged condition largely cancels that effect. With h the mean edge length instead (diagonals included), the numbers shift slightly but the pattern is the same.

9. ★★ Isometries give diagonal functional maps. Assume both shapes have simple eigenvalues and T is an isometry. Prove that C is diagonal with entries \pm 1. What happens on the sphere?

   Solution: by Theorem 5.3, every entry satisfies c_{ij}\, (\lambda^\mathcal{N}_j - \lambda^\mathcal{M}_i) = 0 .

   The spectra coincide (Proposition 3.3) and are simple, so \lambda^\mathcal{N}_j = \lambda^\mathcal{M}_i only for i = j; hence C is diagonal, and orthogonality gives c_{ii}^2 = 1.

   On the sphere the eigenvalue 2 has multiplicity 3, and C has an arbitrary 3 \times 3 orthogonal block there: the rotations of the sphere.

10. ★★ Symmetry and functional maps (computational). In Code 5.8, replace np.cos(2 * D[:, 1] + 0.5) by np.cos(2 * D[:, 1]). Report the error and the diagonal of C, and explain.

    Hints and expected result: the error rises from 0.0053 to 0.137 and the exact hits fall from 79 % to 28 %. Among the first eight diagonal entries of C, three collapse towards 0 (moduli 0.18, 0.15 and 0.07).

    The surface is now symmetric under y \mapsto -y. The eigenfunctions that are odd under this reflection have zero coefficients on every intrinsic descriptor, which is even, so their sign cannot be determined.

11. ★★ Procrustes with a reflection. In 2D, take rest edges e_1 = (1, 0), e_2 = (0, 1) and deformed edges e'_1 = (0, 1), e'_2 = (1, 0), with unit weights.

    Compute S, its SVD, and \operatorname{tr}(R S) for every rotation R. Which orthogonal matrix would be optimal without the constraint \det R = 1?

    Solution: S = e_1 e_1'^\top + e_2 e_2'^\top has entries S_{12} = S_{21} = 1 and zeros elsewhere. Its singular values are 1, 1 and \det(WU^\top) = -1.

    For a rotation by \theta, \operatorname{tr}(RS) = -\sin\theta + \sin\theta = 0: every rotation is optimal, as Theorem 4.3 predicts (\sigma_1 - \sigma_2 = 0). The unconstrained optimum is the reflection S itself, with trace 2. ARAP must exclude it, since a reflection turns triangles inside out.

12. ★★ Angular max pooling. (a) Show that rotating the angular origin of a patch by a multiple of 2\pi / N_\theta leaves the output of Definition 6.4 unchanged, when the maximum runs over the same N_\theta rotations. (b) Give two signals whose patches differ, but which produce the same outputs for every filter supported on one ring \rho = \rho_1.

    Solution:

    • (a) Shifting the origin by 2\pi k / N_\theta shifts the index \theta of the patch. The shift is absorbed by the change of variable \theta_0 \mapsto \theta_0 + 2\pi k / N_\theta in the maximum.
    • (b) Take two patches that agree on the ring \rho_1 up to a rotation by 2\pi/N_\theta but differ elsewhere: filters on that ring cannot tell them apart.

    More generally, after the maximum the orientation at which each filter fired is lost, so the next layer cannot relate the orientations of neighbouring patches; parallel transport (Proposition 6.9) keeps them.

13. ★★ What the eikonal term does not see.

    • (a) On the line, take \Gamma = \{0\} and the “tent” function f(x) = x \ \text{ on } [-1, 1], \qquad f(x) = 2 - x \ \text{ on } [1, 3]. Show that |f'| = 1 almost everywhere and that f vanishes on \Gamma, but has a spurious zero.
    • (b) Prove that a C^2 function with \|\nabla f\| = 1 near a smooth closed curve \Gamma, vanishing on \Gamma, coincides with the signed distance, up to a global sign, in a thin band around \Gamma.

    Solution:

    • (a) f(2) = 0: the eikonal term is satisfied, yet a second zero appears. The data term only sees \Gamma, so nothing in the loss forbids it; IGR relies on the implicit bias of the network and of gradient descent.
    • (b) Differentiating \|\nabla f\|^2 = 1 gives \nabla^2 f\, \nabla f = 0, so \nabla f is constant along its own integral curves, which are straight unit-speed lines.

    Since f vanishes on \Gamma, its gradient there is a unit normal n, with one orientation on the whole curve. Starting from a point p of the curve in this direction, f(p + s\, n(p)) = s.

    For |s| below the reach of \Gamma, the point p + s\, n(p) is at distance |s| from the curve, so f is the signed distance there, for the orientation n.

14. ★★ Fourier feature bandwidth (computational). In Code 8.4, keep the seed and the samples, and train only the Fourier-feature network, created three times in a row with \sigma \in \{1, 10, 100\}. Report train and test errors.

    Hints and expected result: the test errors are about 0.005, 0.0001 and 0.24; the last one varies between about 0.2 and 0.5 with the seed. With \sigma = 1 the high frequency is learned slowly. With \sigma = 100 the training error is zero but the network interpolates between samples with frequencies far above those of the signal: the kernel of Theorem 8.3 is too narrow, the analogue of overfitting.

15. ★★★ Spectral filters that transfer (computational). On the sphere of Code 1.10, compute 16 eigenpairs and build a second valid eigenbasis \Phi Q, with Q a random orthogonal matrix acting inside the eigenspaces of sizes 1, 3, 5, 7. Apply the filter \Phi\, \mathrm{diag}(w)\, \Phi^\top M f in both bases, (a) for random w_k, (b) for w_k = e^{-0.1 \lambda_k}. Then show that the DiffusionNet diffusion is case (b) and compute its derivative with respect to t.

    Hints and expected result: for a random signal f, the relative change of the output is of order 1 (between about 0.7 and 2 over seeds) for random coefficients, and below 10^{-3} for e^{-0.1\lambda}; the residue comes from the discrete eigenvalues being only nearly equal (Proposition 6.3). The diffusion layer is g(\Lambda) = e^{-t\Lambda}, and its derivative is -\Phi \Lambda e^{-t\Lambda} \Phi^\top M x, which is how t is learned.

16. ★★★ Differentiable iso-surfaces. (a) For f(x) = \|x\| - r, apply Proposition 9.5 to a change of r. (b) Do the same for f(x) = \|x\|^2 - r^2 and a change of r^2. (c) Implement marching squares for a 2D field on a grid and check numerically that the extracted vertices move as Proposition 9.5 predicts when the field is perturbed. (d) What happens when \nabla f vanishes, or when the topology of the level set changes?

    Hints and expected result: (a) g = -1 gives \mathrm{d}v/\mathrm{d}r = n: the circle grows at unit speed. (b) \mathrm{d}v / \mathrm{d}(r^2) = 2x / (4r^2) = n / (2r), consistent with \mathrm{d}r / \mathrm{d}(r^2) = 1/(2r). (c) With linear interpolation along grid edges, vertex derivatives match the formula up to the interpolation error. (d) The formula blows up at critical points; at a topology change, vertices appear or disappear, a discontinuity that no derivative captures.

17. ★★★ A learned descriptor for functional maps (research-flavoured). Replace the WKS of Code 5.8 by features computed by the network of Code 7.9, with the WKS or the coordinates as input. Write the solve of Proposition 5.5 with torch.linalg.solve, and train the network so that the computed C matches the ground-truth functional map on pairs of bumpy spheres with random bumps. Evaluate on new shapes, and on symmetric ones.

    Hints and expected result: this is a small version of deep functional maps (Litany et al., 2017; ch. 10). The loss \|C - C_{\text{gt}}\|_F^2 is differentiable through the linear solve. A few dozen training pairs should match the WKS baseline on asymmetric shapes. On symmetric shapes, intrinsic inputs keep the ambiguity of Exercise 10, and extrinsic inputs or an orientation term are needed to resolve it.

Projects and assessment

The official assessment combines the practical sessions (TPs), mini quizzes of 15 minutes every two lectures, and a final project in which students implement a paper from a list proposed by the instructors (master-mva.com); the Université Paris-Saclay course detail lists partial continuous assessment, and no weights are displayed. The subjects below are proposals at the scale of that final project, each built on a named paper and graded with the rubric at the end of this section. The written exam is a proposal of what a written test on the course could look like.

Solo projects

1. [Solo · ≈ 20 h] Geodesics in heat, reproduced. Paper: Crane, Weischedel and Wardetzky (2013).
   • Question: how accurate and how fast is the heat method, and how do t and the boundary conditions matter?
   • Work: implement Algorithm 2.5 with prefactored matrices; compare with exact distances on the sphere and the plane, and with a Dijkstra baseline on the edge graph; reproduce the effect of t and of the averaged boundary condition (Exercise 8).
   • Success: mean error below 1 % of the diameter on a 10 000-vertex sphere, and a timing table for multiple sources.
   • Deliverables: code, 4–6 page report, 10-minute talk. Chapters: ch. 1, ch. 2.
2. [Solo · ≈ 20 h] Functional maps and spectral upsampling. Papers: Ovsjanikov et al. (2012), Melzi et al. (2019).
   • Question: how far do descriptors plus commutativity go, and what does ZoomOut add?
   • Work: extend Code 5.8 to pairs of synthetic shapes related by near-isometric deformations (bending a bumpy cylinder, for example); implement ZoomOut; plot cumulative error curves against k; study symmetric shapes.
   • Success: on every near-isometric pair, ZoomOut started from a coarse map (k_0 = 6) and run to k = 50 lowers its mean error, shown by cumulative error curves (on the pair of Code 5.8, from 0.015 to about 0.009); and a correct diagnosis of the symmetric failures.
   • Deliverables: code, report, talk. Chapters: ch. 3, ch. 5.
3. [Solo · ≈ 20 h] Neural signed distance fields: IGR versus SIREN. Papers: Gropp et al. (2020), Sitzmann et al. (2020).
   • Question: which architecture and which regularisation give the most accurate surface from unoriented points?
   • Work: fit 3D SDFs of analytic shapes (sphere, torus, union of boxes) from sampled points, with and without normals and eikonal term; extract meshes by marching cubes (for example skimage.measure.marching_cubes); measure Chamfer distance and normal error.
   • Success: a Chamfer distance below 1 % of the bounding-box diagonal on the sphere and the torus, a table over shapes and settings, and a figure showing spurious zero sets when the eikonal term is removed.
   • Deliverables: code, report, talk. Chapters: ch. 8.

Group projects

1. [Group of 2–3 · ≈ 30 h each] DiffusionNet from scratch. Paper: Sharp, Attaiki, Crane and Ovsjanikov (2022).
   • Question: does a reimplementation reproduce the robustness of DiffusionNet to remeshing and to point-cloud inputs?
   • Work: implement the full block, with gradient features (Definition 7.6); train on the human body segmentation data of Maron et al. (2017), or on synthetic data if access is an issue; test on remeshed and decimated shapes and on point clouds.
   • Split: operators and data pipeline; network and training; robustness experiments and ablations (without gradient features, with xyz versus HKS inputs).
   • Success: segmentation accuracy within 3 points of the value the paper reports on the original meshes, and a robustness curve.
   • Deliverables: code, joint report of 8–10 pages, 20-minute talk. Chapters: ch. 3, ch. 6, ch. 7.
2. [Group of 2–3 · ≈ 30 h each] Point2Mesh with and without a self-prior. Paper: Hanocka, Metzer, Giryes and Cohen-Or (2020).
   • Question: how much of the quality of Point2Mesh comes from the network prior, compared with explicit regularisers?
   • Work: start from Code 9.7; implement a displacement network on the mesh (a small MeshCNN or a graph network); add coarse-to-fine refinement; compare with direct optimisation plus Laplacian or ARAP regularisation (Definition 4.2) on noisy and incomplete synthetic clouds.
   • Split: data and metrics (Chamfer, normal consistency); network prior; explicit regularisers and the comparison.
   • Success: a figure and a table showing, on at least three shapes, when the self-prior wins.
   • Deliverables: code, joint report, talk. Chapters: ch. 4, ch. 7, ch. 9.

Written exam (proposal)

Two hours, one handwritten A4 sheet allowed, no electronic device; four exercises.

1. Question (4 points). Define intrinsic and extrinsic quantities. Explain why the heat kernel signature is invariant to isometries, give one shape-analysis task where this is an advantage and one where it is a weakness. Expected: the metric determines \Delta and its eigenpairs (Definition 0.1, Proposition 3.3); matching across poses benefits; intrinsic symmetries (left–right) cannot be resolved (Note 5.9).

2. Question (6 points). A regular square pyramid has a unit square base and four lateral equilateral triangles of side 1; consider the closed mesh with the base cut into two triangles. (a) Compute the angle defect at the apex and at a base vertex, and check Theorem 3.8. (b) Compute the cotangent weight of a lateral edge.

   Expected: (a) the apex has four angles of \pi/3, defect 2\pi/3. A base vertex has two angles of \pi/3 and a total of \pi/2 in the base, defect 5\pi/6. The total is \frac{2\pi}{3} + 4 \cdot \frac{5\pi}{6} = 4\pi = 2\pi\chi .

   (b) Each lateral edge faces two angles of 60^\circ, weight 1/\sqrt3.

3. Question (6 points). Prove that the holonomy of discrete parallel transport around an interior vertex equals its angle defect (Theorem 6.7), and deduce the total holonomy over all vertices of a closed mesh. Expected: the unfolding argument. Taking at each vertex the representative equal to the angle defect, Theorem 3.8 gives a total of 2\pi\chi. Modulo 2\pi the total is 0 for every mesh, so the topology is seen by the angle defects, not by the holonomy angles alone.

4. Question (4 points). A ReLU network fitted to \sin 2\pi x + 0.5 \sin 24\pi x reaches a test error of 0.125. Explain this number, and two ways to fix it. Expected: 0.125 is the energy 0.5^2/2 of the missed high-frequency term (spectral bias); Fourier features with a suitable \sigma (Theorem 8.3) or a SIREN with its initialisation (Definition 8.5).

Grading rubric (proposal)

References

The official course pages list no bibliography. The papers that introduced the methods named in the official session organisation come first, then textbooks and the other works cited on this page.

Papers behind the methods named in the official programme

• Crane, K., Weischedel, C., Wardetzky, M. (2013). Geodesics in heat: a new approach to computing distance based on heat flow. ACM Transactions on Graphics, 32(5).
• Maron, H., Galun, M., Aigerman, N., Trope, M., Dym, N., Yumer, E., Kim, V. G., Lipman, Y. (2017). Convolutional neural networks on surfaces via seamless toric covers. ACM Transactions on Graphics, 36(4).
• Sun, J., Ovsjanikov, M., Guibas, L. (2009). A concise and provably informative multi-scale signature based on heat diffusion. Computer Graphics Forum, 28(5).
• Aubry, M., Schlickewei, U., Cremers, D. (2011). The wave kernel signature: a quantum mechanical approach to shape analysis. ICCV Workshops.
• Rustamov, R. M. (2007). Laplace–Beltrami eigenfunctions for deformation invariant shape representation. Symposium on Geometry Processing.
• Masci, J., Boscaini, D., Bronstein, M. M., Vandergheynst, P. (2015). Geodesic convolutional neural networks on Riemannian manifolds. ICCV Workshops.
• Wiersma, R., Eisemann, E., Hildebrandt, K. (2020). CNNs on surfaces using rotation-equivariant features. ACM Transactions on Graphics, 39(4).
• Qi, C. R., Su, H., Mo, K., Guibas, L. J. (2017). PointNet: deep learning on point sets for 3D classification and segmentation. CVPR.
• Hanocka, R., Hertz, A., Fish, N., Giryes, R., Fleishman, S., Cohen-Or, D. (2019). MeshCNN: a network with an edge. ACM Transactions on Graphics, 38(4).
• Sharp, N., Attaiki, S., Crane, K., Ovsjanikov, M. (2022). DiffusionNet: discretization agnostic learning on surfaces. ACM Transactions on Graphics, 41(3).
• Wiersma, R., Nasikun, A., Eisemann, E., Hildebrandt, K. (2022). DeltaConv: anisotropic operators for geometric deep learning on point clouds. ACM Transactions on Graphics, 41(4).
• Gong, S., Chen, L., Bronstein, M., Zafeiriou, S. (2019). SpiralNet++: a fast and highly efficient mesh convolution operator. ICCV Workshops.
• Mildenhall, B., Srinivasan, P. P., Tancik, M., Barron, J. T., Ramamoorthi, R., Ng, R. (2020). NeRF: representing scenes as neural radiance fields for view synthesis. ECCV.
• Park, J. J., Florence, P., Straub, J., Newcombe, R., Lovegrove, S. (2019). DeepSDF: learning continuous signed distance functions for shape representation. CVPR.
• Mescheder, L., Oechsle, M., Niemeyer, M., Nowozin, S., Geiger, A. (2019). Occupancy networks: learning 3D reconstruction in function space. CVPR.
• Tancik, M., Srinivasan, P. P., Mildenhall, B., Fridovich-Keil, S., Raghavan, N., Singhal, U., Ramamoorthi, R., Barron, J. T., Ng, R. (2020). Fourier features let networks learn high frequency functions in low dimensional domains. NeurIPS.
• Sitzmann, V., Martel, J. N. P., Bergman, A. W., Lindell, D. B., Wetzstein, G. (2020). Implicit neural representations with periodic activation functions. NeurIPS.
• Wang, Y., Rahmann, L., Sorkine-Hornung, O. (2022). Geometry-consistent neural shape representation with implicit displacement fields. ICLR.
• Hertz, A., Hanocka, R., Giryes, R., Cohen-Or, D. (2020). Deep geometric texture synthesis. ACM Transactions on Graphics, 39(4).
• Hanocka, R., Metzer, G., Giryes, R., Cohen-Or, D. (2020). Point2Mesh: a self-prior for deformable meshes. ACM Transactions on Graphics, 39(4).

Textbooks and surveys

• do Carmo, M. P. (1976). Differential Geometry of Curves and Surfaces. Prentice-Hall.
• Botsch, M., Kobbelt, L., Pauly, M., Alliez, P., Lévy, B. (2010). Polygon Mesh Processing. A K Peters / CRC Press.
• Bronstein, A. M., Bronstein, M. M., Kimmel, R. (2008). Numerical Geometry of Non-Rigid Shapes. Springer.
• Crane, K. (2018). Discrete Differential Geometry: An Applied Introduction. Lecture notes, Carnegie Mellon University.
• Bronstein, M. M., Bruna, J., LeCun, Y., Szlam, A., Vandergheynst, P. (2017). Geometric deep learning: going beyond Euclidean data. IEEE Signal Processing Magazine, 34(4).
• Bronstein, M. M., Bruna, J., Cohen, T., Veličković, P. (2021). Geometric deep learning: grids, groups, graphs, geodesics, and gauges. arXiv:2104.13478.
• Ovsjanikov, M., Corman, E., Bronstein, M., Rodolà, E., Ben-Chen, M., Guibas, L., Chazal, F., Bronstein, A. (2016). Computing and processing correspondences with functional maps. SIGGRAPH Asia Courses.

Discrete differential geometry and geometry processing

• Pinkall, U., Polthier, K. (1993). Computing discrete minimal surfaces and their conjugates. Experimental Mathematics, 2(1).
• Desbrun, M., Meyer, M., Schröder, P., Barr, A. H. (1999). Implicit fairing of irregular meshes using diffusion and curvature flow. SIGGRAPH.
• Meyer, M., Desbrun, M., Schröder, P., Barr, A. H. (2003). Discrete differential-geometry operators for triangulated 2-manifolds. In Visualization and Mathematics III, Springer.
• Bobenko, A. I., Springborn, B. A. (2007). A discrete Laplace–Beltrami operator for simplicial surfaces. Discrete & Computational Geometry, 38(4).
• Varadhan, S. R. S. (1967). On the behavior of the fundamental solution of the heat equation with variable coefficients. Communications on Pure and Applied Mathematics, 20(2).
• Reuter, M., Wolter, F.-E., Peinecke, N. (2006). Laplace–Beltrami spectra as “Shape-DNA” of surfaces and solids. Computer-Aided Design, 38(4).
• Gordon, C., Webb, D., Wolpert, S. (1992). One cannot hear the shape of a drum. Bulletin of the American Mathematical Society, 27(1).
• Sorkine, O., Cohen-Or, D., Lipman, Y., Alexa, M., Rössl, C., Seidel, H.-P. (2004). Laplacian surface editing. Symposium on Geometry Processing.
• Sorkine, O., Alexa, M. (2007). As-rigid-as-possible surface modeling. Symposium on Geometry Processing.
• Tutte, W. T. (1963). How to draw a graph. Proceedings of the London Mathematical Society, s3-13(1).
• Floater, M. S. (1997). Parametrization and smooth approximation of surface triangulations. Computer Aided Geometric Design, 14(3).
• Floater, M. S. (2003). One-to-one piecewise linear mappings over triangulations. Mathematics of Computation, 72(242).
• Lévy, B., Petitjean, S., Ray, N., Maillot, J. (2002). Least squares conformal maps for automatic texture atlas generation. ACM Transactions on Graphics, 21(3).
• Ovsjanikov, M., Ben-Chen, M., Solomon, J., Butscher, A., Guibas, L. (2012). Functional maps: a flexible representation of maps between shapes. ACM Transactions on Graphics, 31(4).
• Melzi, S., Ren, J., Rodolà, E., Sharma, A., Wonka, P., Ovsjanikov, M. (2019). ZoomOut: spectral upsampling for efficient shape correspondence. ACM Transactions on Graphics, 38(6).
• Lorensen, W. E., Cline, H. E. (1987). Marching cubes: a high resolution 3D surface construction algorithm. SIGGRAPH (Computer Graphics, 21(4)).
• Sharp, N., Soliman, Y., Crane, K. (2019). The vector heat method. ACM Transactions on Graphics, 38(3).
• Sharp, N., Crane, K. (2020). A Laplacian for nonmanifold triangle meshes. Computer Graphics Forum, 39(5).

Geometric deep learning

• Bruna, J., Zaremba, W., Szlam, A., LeCun, Y. (2014). Spectral networks and locally connected networks on graphs. ICLR.
• Boscaini, D., Masci, J., Rodolà, E., Bronstein, M. M. (2016). Learning shape correspondence with anisotropic convolutional neural networks. NeurIPS.
• Monti, F., Boscaini, D., Masci, J., Rodolà, E., Svoboda, J., Bronstein, M. M. (2017). Geometric deep learning on graphs and manifolds using mixture model CNNs. CVPR.
• Zaheer, M., Kottur, S., Ravanbakhsh, S., Póczos, B., Salakhutdinov, R., Smola, A. (2017). Deep sets. NeurIPS.
• Wang, Y., Sun, Y., Liu, Z., Sarma, S. E., Bronstein, M. M., Solomon, J. M. (2019). Dynamic graph CNN for learning on point clouds. ACM Transactions on Graphics, 38(5).
• Litany, O., Remez, T., Rodolà, E., Bronstein, A., Bronstein, M. (2017). Deep functional maps: structured prediction for dense shape correspondence. ICCV.
• Cohen, T., Weiler, M., Kicanaoglu, B., Welling, M. (2019). Gauge equivariant convolutional networks and the icosahedral CNN. ICML.
• de Haan, P., Weiler, M., Cohen, T., Welling, M. (2021). Gauge equivariant mesh CNNs: anisotropic convolutions on geometric graphs. ICLR.
• Mitchel, T. W., Kim, V. G., Kazhdan, M. (2021). Field convolutions for surface CNNs. ICCV.
• Deng, C., Litany, O., Duan, Y., Poulenard, A., Tagliasacchi, A., Guibas, L. (2021). Vector neurons: a general framework for SO(3)-equivariant networks. ICCV.
• Cao, D., Roetzer, P., Bernard, F. (2023). Unsupervised learning of robust spectral shape matching. ACM Transactions on Graphics, 42(4).
• Attaiki, S., Ovsjanikov, M. (2023). Understanding and improving features learned in deep functional maps. CVPR.

Neural fields and 3D generation

• Gropp, A., Yariv, L., Haim, N., Atzmon, M., Lipman, Y. (2020). Implicit geometric regularization for learning shapes. ICML.
• Müller, T., Evans, A., Schied, C., Keller, A. (2022). Instant neural graphics primitives with a multiresolution hash encoding. ACM Transactions on Graphics, 41(4).
• Yariv, L., Gu, J., Kasten, Y., Lipman, Y. (2021). Volume rendering of neural implicit surfaces. NeurIPS.
• Wang, P., Liu, L., Liu, Y., Theobalt, C., Komura, T., Wang, W. (2021). NeuS: learning neural implicit surfaces by volume rendering for multi-view reconstruction. NeurIPS.
• Kerbl, B., Kopanas, G., Leimkühler, T., Drettakis, G. (2023). 3D Gaussian splatting for real-time radiance field rendering. ACM Transactions on Graphics, 42(4).
• Liao, Y., Donné, S., Geiger, A. (2018). Deep marching cubes: learning explicit surface representations. CVPR.
• Remelli, E., Lukoianov, A., Richter, S., Guillard, B., Bagautdinov, T., Baqué, P., Fua, P. (2020). MeshSDF: differentiable iso-surface extraction. NeurIPS.
• Shen, T., Gao, J., Yin, K., Liu, M.-Y., Fidler, S. (2021). Deep marching tetrahedra: a hybrid representation for high-resolution 3D shape synthesis. NeurIPS.
• Shen, T., Munkberg, J., Hasselgren, J., Yin, K., Wang, Z., Chen, W., Gojcic, Z., Fidler, S., Sharp, N., Gao, J. (2023). Flexible isosurface extraction for gradient-based mesh optimization. ACM Transactions on Graphics, 42(4).
• Nash, C., Ganin, Y., Eslami, S. M. A., Battaglia, P. (2020). PolyGen: an autoregressive generative model of 3D meshes. ICML.
• Siddiqui, Y., Alliegro, A., Artemov, A., Tommasi, T., Sirigatti, D., Rosov, V., Dai, A., Nießner, M. (2024). MeshGPT: generating triangle meshes with decoder-only transformers. CVPR.
• Luo, S., Hu, W. (2021). Diffusion probabilistic models for 3D point cloud generation. CVPR.
• Poole, B., Jain, A., Barron, J. T., Mildenhall, B. (2023). DreamFusion: text-to-3D using 2D diffusion. ICLR.

Data sets

• Bogo, F., Romero, J., Loper, M., Black, M. J. (2014). FAUST: dataset and evaluation for 3D mesh registration. CVPR.
• Wu, Z., Song, S., Khosla, A., Yu, F., Zhang, L., Tang, X., Xiao, J. (2015). 3D ShapeNets: a deep representation for volumetric shapes. CVPR.