Assignment 4

Geometry Processing, Spring 2026

Michael Kazhdan

Assignment 4: Gradient-domain filtering and Geodesics-in-Heat

Due on April 4 (Saturday) at 11:59 PM

Announcements

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/RiemannianMesh.[h/inl], GradientDomainFiltering/GradientDomainFiltering.cpp, and GeodesicsInHeat/GeodesicsInHeat.cpp files. (Feel free to declare and define additional member functions in Include/RiemannianMesh.[h/inl] as you need them.)

After you download the files, the first thing to do is compile the GradientDomainFiltering and GeodesicsInHeat executables.

On a Windows Machine
Begin by double-clicking on GeometryProcessing.sln to open the workspace in Microsoft Visual Studios.
- Compile the GradientDomainFiltering and GeodesicsInHeat executables 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 executables GradientDomainFiltering and GeodesicsInHeat are 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 GradientDomainFiltering and GeodesicsInHeat executables.
- The executables GradientDomainFiltering and GeodesicsInHeat are compiled in Release mode and will be placed in the directory Bin/Linux.

How to Invoke the Executable

GradientDomainFiltering

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 supporting the "painting" of modulation weights on mesh triangles, and the solving of the associated gradient-domain problem to obtain smoothed/sharpened vertex positions.
To see the supported command line arguments, run the executable without an argyments:

% GradientDomainFiltering

To smooth the geometry, invoke the executable as:

% GradientDomainFiltering --in <input geometry> --dWeight <differential fitting weight>

With:

<input geometry> the geometry to be processed.
<differential fitting weight> the importance assigned to fitting the scalar field to the target differential in the gradient-domain formulation. (The weight for the value-fitting is 1.)

GeodesicsInHeat

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 supporting the selection of a source vertex and the computation of the geodesics distance from the source to all mesh vertices.
To see the supported command line arguments, run the executable without an argyments:

% GeodesicsInHeat

To smooth the geometry, invoke the executable as:

% GeodesicsInHeat --in <input geometry> --dTime <delta diffusion time> --rWeight <regularization weight>

With:

<input geometry> the geometry to be processed.
<delta diffusion time> the time-step for diffusing the delta function centered at the source vertex.
<regularization weight> the (tiny) weight used to encourage the scalar field to have values centered about 0.

How to Interact with the Executable

GradientDomainFiltering

Upon invocation, the executable will open an OpenGL window where local smoothing/sharpening weights can be prescribed.
The basic supported interfaces are:

[space] pauses/resumes the animation
[left mouse] rotates
[right mouse] zooms
[left mouse]+[ctrl] pans
'[' decreases the differential fitting weight
']' increases the differential fitting weight
'v' toggles modulation weight visualization
's' enters selection mode
'{' decreases the radius of the selection ball
'}' increases the radius of the selection ball
[left mouse] (in selection mode) decreases the modulation weight in the selected region
[right mouse] (in selection mode) increases the modulation weight in the selected region

GeodesicsInHeat

Upon invocation, the executable will open an OpenGL window where local smoothing/sharpening weights can be prescribed.
The basic supported interfaces are:

[left mouse] rotates
[right mouse] zooms
[left mouse]+[ctrl] pans
[left mouse click] sets the source vertex
'[' decreases the number of bands
']' increases the number of bands

What You Have to Do

Include/RiemannianMesh.inl:

You will need to modify this file to support the computation of the cotangent vector field mass matrix and the differential matrix taking coefficients of a scalar function to the coefficients of its differential. To do this you will need to complete the bodies of the two methods:

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

Please note, that the last argument to the first 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::CotangentMass( const Mesh & mesh )
RiemannianMesh::Differential( const Mesh & mesh )

as these will extract the necessary data from the Mesh object, and construct the functor (for computing the mass matrix), and pass that to the functions computing the mass and stiffness matrices.

GradientDomainFiltering/GradientDomainFiltering.cpp:

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

In the body of the GradientDomainFiltering constructor, you will need to initially set up the solver, GDFiltering::_solver.
You will need to fill in the body of the GradientDomainFiltering::_updateNumericalFactorization member function 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.)
This will be invoked if you modify the differential fitting weight (with the '[' and ']' keys).
You will need to fill in the body of the GradientDomainFiltering::animate member function to compute the modulated target differential and solve the gradient-domain problem.
This will be invoked if either the user changes the modulation weights associated with the triangles or if the differential fitting weight is changed.

GeodesicsInHeat/GeodesicsInHeat.cpp:

You will need to modify this file to support the compuationg of geodesics distances from the source in two places:

In the body of the GeodesicsInHeat constructor, you will need to initially set up the solvers, GeodesicsInHeat:_diffusionSolver and GeodesicsInHeat::_distanceSolver.
You will need to fill in the body of the GeodesicsInHeat::animate member function to
1. Construct the delta functional associated with the selected vertex, given by GeodesicsInHeat::_sourceIndex
2. Diffuse the delta for a short time period, given by GeodesicsInHeat::diffusionTime
3. Compute and adjust the differential of the diffused delta.
4. Fit a scalar field to the target differentials, adding a value regularization with weight GeodesicsInHeat::regularizationWeight
5. Adjust the scalar field so that the distance to the source vertex is 0.

Please see the assignment description for additional details.

Questions

When modulating the gradients for smoothing/sharpening, what is the effect of increasing/decreasing the differential fitting weight?
When computing geodesic distances, what happens when the diffusion time is decreased/increased?

What to Submit

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

Your modified Include/RiemannianMesh.[h/inl], GradientDomainFiltering/GradientDomainFiltering.cpp, and GeodesicsInHeat/GeodesicsInHeat.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.)