Assignment 2

Geometry Processing, Spring 2026

Michael Kazhdan

Assignment 3: Laplacian Smoothing

Due on March 14 (Saturday) at 11:59 PM

Announcements

[2/19/26] The OneRingSmoothing project/code/executable has been renamed OneRingAveraging.

Overview

In this assignment you will implement the correct Laplacian smoothing algorithm in which, at each time-step, the vertex positions are updated by performing a semi-implicit time-step of the gradient descent PDE, using the correct bilinear form for stiffness, and transforming the differential of the Dirichlet energy into a gradient. The smoothing will be applied to the x-, y-, and z-coordinates, resulting in the smoothing of the geometry itself.

The code skeleton can be downloaded here.
Example models you can use for testing can be found here.
A detailed description of the assignment can be found here.

Getting Started

You should use the code (GeometryProcessing.zip) as a starting point for your assignment. We provide you with numerous files, but you should only have to change the Include/Mesh.inl, Include/RiemannianMesh.[h/inl], and LaplacianSmoothing/LaplacianSmoothing.cpp files. (Feel free to declare and define additional member functions in Include/RiemannianMesh.[h/inl] as you need them.)
Please note that the Include/DynamicMeshViewer.[h/inl] have also been modified.

After you download the files, the first thing to do is compile the LaplacianSmoothing executable.

On a Windows Machine
Begin by double-clicking on GeometryProcessing.sln to open the workspace in Microsoft Visual Studios.
- Compile the LaplacianSmoothing executable by clicking on "Build" and then selecting "Build Solution". Please be sure that you are compiling for Release under x64 mode, as only those project settings were set. (If you need to compile under Debug, you will need to copy over the settings.)
- The executable LaplacianSmoothing.exe is compiled in Release mode for the 64-bit architecture and will be placed in the directory Bin/x64.
On a Unix/Mac Machine
- Type make to compile the LaplacianSmoothing executable.
- The executable LaplacianSmoothing is compiled in Release mode and will be placed in the directory Bin/Linux.

How to Invoke the Executable

The executable runs on the command line. It takes a geometry file as input, either in ply or in obj file format (determined by the file extension) and opens up an OpenGL-based viewer visualizing progressive smoothing the vertex positions.
To see the supported command line arguments, run the executable without an argyments:

% LaplacianSmoothing

To smooth the geometry, invoke the executable as:

% LaplacianSmoothing --in <input geometry> --stepSize <gradient-descent step-size>

With:

<input geometry> the geometry to be processed.
<gradient-descent step-size> the step-size to be used for time-stepping the gradient-descent PDE. (Default value is 10^-4.)

The code also supports the following flags:

--updateMass: Tells the executable to update the mass matrix when the vertex positions are updated.
--updateStiffness: Tells the executable to update the stiffness matrix when the vertex positions are updated.
--normalize: Tells the exeuctable to normalize the mesh -- translating it and scaling it so that the normalized mesh is centered at the origin and has unit area. (Since smoothing tends to shrink the geometry, this can be useful to see longer range effects.)

How to Interact with the Executable

Upon invocation, the executable will open an OpenGL window where the smoothing will be animated.
The basic supported interfaces are:

[space] pauses/resumes the animation
[left mouse] rotates
[right mouse] zooms
[left mouse]+[ctrl] pans
'[' decreases the step-size
']' increases the step-size

What You Have to Do

Include/Mesh.inl:

You will need to implement the member function Mesh::g so that, given the index of a triangle, it returns the Eigen::Matrix< double , 2 , 2 > describing the inner-product on the tangent space.

Include/RiemannianMesh.inl:

You will need to modify this file to support the computation of the mass and stiffness matrices. To do this you will need to complete the bodies of the two methods:

RiemannianMesh::ScalarMass( size_t vNum , const std::vector< SimplexIndex< K > > & triangles , MetricFunctor && metricFunctor )
RiemannianMesh::ScalarStiffness( size_t vNum , const std::vector< SimplexIndex< K > > & triangles , MetricFunctor && metricFunctor )

Please note, that the last argument to both member functions is an object of type MetricFunctor. This is a functor that takes as it's input an integer indexing a triangle and returns a Eigen::Matrix< double , 2 , 2 > object giving the pulled-back inner-product on the tangent space. Your implementation should not need access to the vertices of the mesh.
In your code, you should only have to invoke the functions:

RiemannianMesh::ScalarMass( const Mesh & mesh )
RiemannianMesh::ScalarStiffness( const Mesh & mesh )

as these will extract the necessary from the Mesh object, construct the functor, and pass that along to the functions computing the mass and stiffness matrices.

LaplacianSmoothing/LaplacianSmoothing.inl:

You will need to modify this file to support the factorization of the system matrix in two places:

In the body of the LaplacianSmoothingViewer constructor, you will need to initially set up the solver, LaplacianSmoothingViewer::_solver.
You will need to fill in the body of the LaplacianSmoothingViewer::_updateNumericalFactorization to update the solver when the system matrix has changed. (Recall that, since the connectivity of the mesh has not changed, you only need to update the numerical factorization, not the symbolic one.)

The latter will be invoked if either you modify the step-size (with the '[' and ']' keys), or if you run the executable with either of the --updateMass or --updateStiffness flags (which re-compute the new mass and/or stiffness matrices defined by the updated geometry).

Please see the assignment description for additional details.

Questions

What happens to the geometry if you iterate the linear formulation?
What happens to the geometry if you iterate the non-linear formulation, updating both the mass and stiffness matrices with the geometry?
What happens to the geometry if you iterate the non-linear formulation, updating just the mass matrix with the geometry?

What to Submit

Please submit your implementation on canvas.
For this assignment, you should submit:

Your modified Include/Mesh.inl, Include/RiemannianMesh.[h/inl] and LaplacianSmoothing/LaplacianSmoothing.cpp files.
A write-up describing what you have implemented. (Particularly, if things did not work as expected, please provide guidance that would allow us to give you partial credit.)