## Assignment 6 [Coding]: Vector Field Decomposition and Design (Due 5/21)

Note: For the final assignment, you can do either this assignment or A5. Overall, you just need to be sure you completed A0 and A1, as well as 3 of the assignments A2–A6 (your choice which ones. See this Piazza post for more details.) Also, you cannot use late days on this assignment since it’s the last one.

Please implement the following routines in:

1. projects/vector-field-decomposition/tree-cotree.[js|cpp]:
1. buildPrimalSpanningTree
2. inPrimalSpanningTree
3. buildDualSpanningCotree
4. inDualSpanningCotree
5. buildGenerators
2. projects/vector-field-decomposition/harmonic-bases.[js|cpp]:
1. buildClosedPrimalOneForm
2. compute

In addition, please implement either Hodge Decomposition, or Trivial Connections (on surfaces of genus 0):

Hodge Decomposition: Please implement the following routines in

1. projects/vector-field-decomposition/hodge-decomposition.js:
1. constructor
2. computeExactComponent
3. computeCoExactComponent
4. computeHarmonicComponent

Trivial Connections on Surfaces of Genus 0: Please implement computeConnections in projects/direction-field-design/trivial-connections.js. This file has function signatures for trivial connections on arbitrary surfaces, but for this assignment we are only requiring you to compute the connection form on simply-connected surfaces where you don’t have to worry about the period matrix. You are, of course, welcome to implement the general algorithm if you would like to!

Notes:

• Recall that homology generators are a set of loops which somehow describe all of the interesting loops on a surface. For example, here are the two homology generators for the torus.
• Your buildGenerators function should implement the Tree-Cotree algorithm, which is Algorithm 5 of section 8.2 of the notes.
• In tree-cotree.js the trees are stored using the dictionaries vertexParent and faceParent. You should store the primal spanning tree by storing the parent of vertex v in vertexParent[v]. The root should be its own parent. Similarly, you should store the dual spanning cotree by storing the parent of face f in faceParent[f].
• The Tree Cotree algorithm finds homology generators on the dual mesh. That is to say, you should take each dual edge which is not in either spanning tree, and form a loop by following its endpoint back up the dual cotree until they meet at the root of the dual cotree. Even though we’re thinking of these homology generators as loops on the dual mesh, we still store them as lists of ordinary halfedges, since edges in the dual mesh are in 1-1 correspondence with edges in the primal graph.
• buildClosedPrimalOneForm should use a homology generator to construct a closed primal 1-form as described in section 8.22 of the notes.
• The compute function in HarmonicBases should compute a harmonic basis using Algorithm 6 in section 8.2 of the notes. If you choose to implement Hodge decomposition for the assignment, you are welcome to use your Hodge decomposition code to solve for $d\alpha$. Otherwise, you can just ignore the hodgeDecomposition parameter and directly solve the linear system $\Delta \alpha = \delta \omega$ to find $\alpha$. (Recall that $\delta$ is the codifferential, which we talked a lot about in the Discrete Exterior Calculus assignment).

Notes (Hodge Decomposition):

• The procedure for Hodge Decomposition is given as Algorithm 3 in section 8.1 of the Notes.
• Note that the SparseMatrix class has an invertDiagonal function that you can use to invert diagonal matrices.
• For computeCoExactComponent, you should compute the coexact component $\delta \beta$ of a differential form $\omega$ by solving the equation $d\delta \beta = d\omega$. As stated in the notes, the most convenient way of doing this is to define a dual 0-form $\tilde \beta := *\beta$, and then to solve $d*d \tilde \beta = d \omega$. Then you can compute $\delta \beta$ using the fact that $\delta \beta = *d*\beta = *d\tilde\beta$. When doing these computations, you should keep tract of whether your forms are primal forms or dual forms, recalling that hodge stars take you from primal forms to dual forms, and hodge star inverses take you from dual forms to primal forms. (THis is discussed in detail in section 8.1.3 of the notes.
• Note that the 2-form Laplacian B is not necessarily positive definite, so you should use an LU solver instead of a Cholesky solver when solving systems involving B.

Notes (Trivial Connections):

• The trivial-connection-js file is structured for implementing the full trivial connections algorithm on arbitrary surfaces. Since that’s tricky, we’re only requiring that you compute connections on topological spheres. You should implement this in the computeConnections() function, and it should pass the tests labeled “computeConnections on a sphere”.
• Even though we’re working with spheres, it is still helpful to use the formulation of Trivial connections given in section 8.4.1 of the notes. In particular, you should solve the optimization problem given in Exercise 8.21.
• On a sphere, there are no harmonic 1-forms, so the $\gamma$ part of your Hodge decomposition will always be 0. Furthermore, the sphere has no homology generators, so the problem simplifies to $\min_{\delta \beta} \;\|\delta\beta\|^2\;\text{s.t.}\; d\delta\beta = u$
• Following the notes, we observe that the constraint $d\delta\beta = u$ determines $\beta$ up to a constant, and that constant is annihilated by $\delta$. So you can find the connection 1-form $\delta \beta$ with a single linear solve.

Submission Instructions
Please submit all source files to Gradescope by 5:59pm ET on May 21, per the usual submission instructions.

Warning: You cannot use late days on this assignment since it’s the last one.

## Assignment 6 [Written]: Vector Field Decomposition and Design (Due 5/21)

Note: For the final assignment, you can do either this assignment or A5. Overall, you just need to be sure you completed A0 and A1, as well as 3 of the assignments A2–A6 (your choice which ones. See this Piazza post for more details.) Also, you cannot use late days on this assignment since it’s the last one.

In this assignment, you will investigate tools for working with tangent vector fields on surfaces. Tangent vector fields are central to classical differential geometry, and have many interesting applications. For this homework, we’ll look at one algorithm for designing vector fields, and along the way we’ll cover a lot of deep facts about surfaces.

There’s no PDF this week since the exercises are all from the notes. The notes will also give you all the background you’ll need to complete this assignment. It builds on a lot of the stuff we’ve already done in the class, especially discrete exterior calculus and the Laplacian.

Submit your written responses for Exercise 8.1 – Exercise 8.21 in the notes to Gradescope (per the usual submission instructions), except for Exercise 8.13.

Warning: You cannot use late days on this assignment since it’s the last one.

## Supplemental Videos: Geodesic Distance and Beyond

In completing your assignment for finals next week, we thought you might find a couple videos helpful (though totally optional). The first was already linked to in the assignment writeup, which gives a reasonably short (18 minutes) motivation for and description of the algorithm you’ll be implementing. The second is a longer (50 minute) talk that covers the algorithm in more detail, and describes some fun extensions and applications of the same basic technique:

Enjoy!

## Assignment 5 [Coding]: Geodesic Distance (Due 5/21)

Note: For the final assignment, you can do either this assignment or A6. Overall, you just need to be sure you completed A0 and A1, as well as 3 of the assignments A2–A6 (your choice which ones. See this Piazza post for more details.) Also, you cannot use late days on this assignment since it’s the last one.

For the coding portion of your final assignment, you will implement the heat method, which is an algorithm for computing geodesic distance on curved surfaces. All of the details you need for implementation are described in Section 3 of the paper, up through and including Section 3.2. Note that you need only be concerned with the case of triangle meshes (not polygon meshes or point clouds); pay close attention to the paragraph labeled “Choice of Timestep.”

Please implement the following routines in:

1. projects/geodesic-distances/heat-method.[js|cpp]:
1. constructor
2. computeVectorField
3. computeDivergence
4. compute

Notes

• Refer to sections 3.2 of the paper for discretizations of Algorithm 1 (page 3).
• Recall that our Laplace matrix is positive semidefinite, which might differ from the sign convention the authors use.
• The tests for computeVectorField and computeDivergence depend on the A and F matrices you define in your constructor. So if you fail the tests but your functions look correct, check whether you have defined the flow and laplace matrices properly.
• Your solution should implement zero neumann boundary conditions (which are the “default behavior” of the cotan Laplacian) but feel free to tryout other Dirichlet and Neumann boundary conditions on your own.

Submission Instructions

## Assignment 5 [Written]: Geodesic Distance (Due 5/21)

Here’s the writeup for your last assignment, which plays the role of the final in the course. (Note that there is no final exam!)

Note: For the final assignment, you can do either this assignment or A6. Overall, you just need to be sure you completed A0 and A1, as well as 3 of the assignments A2–A6 (your choice which ones. See this Piazza post for more details.) Also, you cannot use late days on this assignment since it’s the last one.

This time, we’re taking off the “training wheels” and having you read a real paper, rather than course notes. Why? Because you’re ready for it! At this point you have all the fundamental knowledge you need to go out into the broader literature and start implementing all sorts of algorithms that are built on top of ideas from differential geometry. In fact, this particular algorithm is not much of a departure from things you’ve done already: solving simple equations involving the Laplacian on triangle meshes. As discussed in our lecture on the Laplacian, you’ll find many algorithms in digital geometry processing that have this flavor: compute some basic data (e.g., using a local formula at each vertex), solve a Laplace-like equation, compute some more basic data, and so on.

Your main references for this assignment will be:

• this video, which gives a brief (18-minute) overview of the algorithm, and
• this paper, which explains the algorithm in detail.

Written exercises for this assignment are found below. Submit your responses to Gradescope by 5:59pm ET, May 21, 2021.

## Lectures 21 & 22 — Geodesics

Our final lectures for the term focus on geodesics, which generalize the notion of “straight line” to curved spaces; this material also connects to your final assignment, on computing geodesic distance. Once again we’ll play “The Game” of discrete differential geometry, and see how two natural characterizations from the smooth setting (straightest and locally shortest) lead to two distinct, and fascinating definitions in the discrete setting. Along the way we’ll also encounter many rich topics from (discrete) differential geometry including the cut locus, the medial axis, the exponential/log map, the covariant derivative, and the Lie bracket! We’ll also see how all this stuff connects with practical algorithms for things like surface reconstruction from points, and give two different algorithms for tracing out geodesics on curved surfaces.

Note that the lecture video comprises about two lectures (about two hours total). I’d recommend watching it in two logical chunks:

• Part I: Shortest Geodesics – 0:00—1:04
• Part II: Straightest Geodesics – 1:04–1:55

## Assignment 4 [Coding]: Conformal Parameterization (Due 5/6)

For the coding portion of your assignment on conformal parameterization, you will implement the Spectral Conformal Parameterization (SCP) algorithm as described in the course notes.Please implement the following routines in

1. core/geometry.[js|cpp]:
1. complexLaplaceMatrix
2. projects/parameterization/spectral-conformal-parameterization.[js|cpp]:
1. buildConformalEnergy
2. flatten
3. utils/solvers.[js|cpp]:
1. solveInversePowerMethod
2. residual

Notes

• Warning: In the notes, the residual is defined as the vector $Ax – \lambda x$. But your function residual  should return a float. You should return $\frac{\|Ax – \lambda x\|_2}{\|x\|_2}$. Furthermore, you should compute $\lambda$ as $\frac{x^* Ax}{x^* x}$ where $x^*$ is the conjugate transpose of $x$.
• The complex version of the cotan-Laplace matrix can be built in exactly the same manner as its real counterpart. The only difference now is that the cotan values of our matrix will be complex numbers with a zero imaginary component. This time, we will work with meshes with boundary, so your Laplace matrix will have to handle boundaries properly (you just have to make sure your cotan function returns 0 for halfedges which are in the boundary).
• The buildConformalEnergy function builds a $|V| \times |V|$ complex matrix corresponding to the conformal energy $E_C(z) = E_D(z) – \mathcal A(Z)$ where $E_D$ is the Dirichlet energy (given by our complex cotan-Laplace matrix) and $\mathcal A$ is the total signed area of the region $z(M)$ in the complex plane (Please refer to Section 7.4 of the notes for more details). You may find it easiest to iterate over the halfedges of the mesh boundaries to construct the area matrix (Recall that the Mesh object in the JS framework has a boundaries variable which stores all the boundary loops; similarly in Geometry Central you can iterate directly over boundary loops.)
• The flatten function returns a dictionary mapping each vertex to a vector of planar coordinates by finding the eigenvector corresponding to the smallest eigenvalue of the conformal energy matrix. You can compute this eigenvector by using solveInversePowerMethod (described below).
• Your solveInversePowerMethod function should implement Algorithm 1 in Section 7.5 of the course notes with one modification – after computing $Ay_i = y_{i-1}$, center $y_i$ around the origin by subtracting its mean. You don’t have to worry about the $B$ matrix or generalized eigenvalue problem. Important: Terminate your iterations when your residual is smaller that 10^-10.
• The parameterization project directory also contains a basic implementation of the Boundary First Flattening (BFF) algorithm. Feel free to play around with it in the viewer and compare the results to your SCP implementation.

Submission Instructions

## Assignment 4 [Written]: Conformal Parameterization (Due 5/6)

The written part of your next assignment, on conformal surface flattening, is now available below. Conformal flattening is important for (among other things) making the connection between processing of 3D surfaces, and existing fast algorithms for 2D image processing. You’ll have the opportunity to implement one of these algorithms in the coding part of the assignment.

## Reading 7—Discrete Conformal Geometry (Due 5/3)

Your next reading will take a deep dive into conformal geometry and the many ways to discretize and compute conformal maps. This subject makes some beautiful and unexpected connections to other areas of mathematics (such as circle packings, and hyperbolic geometry), and is in some sense one of the biggest “success stories” of DDG, since there is now a complete uniformization theorem that mirrors the one on the smooth side. You’ll find out more about what this all means in the reading! The reading comes from the note, “Conformal Geometry of Simplicial Surface”:

For your assignment you will need to read the Overview (1.1) and Preliminaries (1.2); you must also pick one of Part I, Part II, or Part III to read, each of which covers a different perspective on discrete conformal maps. The most interesting subject, perhaps, is the connections to hyperbolic geometry in Part IV, which you can read for your own enjoyment! 🙂

Hand-in instructions are, as usual, found on the assignments page. The reading is due at 10 AM Eastern, May 3, 2021.

## Lectures 19 & 20: Conformal Geometry

A basic task in geometric algorithms is finding mappings between surfaces, which can be used to transfer data from one place to another. A particularly nice class of algorithms (both from a mathematical and computational perspective) are conformal mappings, which preserve angles between vectors, and are generally very well-behaved. In this lecture we’ll take a look at smooth characterizations of conformal maps, which will ultimately inspire the way we talk about conformal maps in the discrete/computational setting.

The video covering both today and Thursday’s lecture (on discrete aspects of conformal maps) can be found here.

## Lecture 18: The Laplace-Beltrami Operator

In this lecture we take a close look at the Laplacian, and its generalization to curved spaces via the Laplace-Beltrami operator. The Laplacian is one of the most fundamental objects in geometry and physics, and which plays a major role in algorithms. Here we consider several perspectives to build up some basic intuition about what the Laplacian is, and what it means.

## Lecture 17—Discrete Curvature II (Variational Viewpoint)

In this lecture we wrap up our discussion of discrete curvature, and see how it all fits together into a single unified picture that connects the integral viewpoint, the variational viewpoint, and the Steiner formula. Along the way we’ll touch upon several of the major players in discrete differential geometry, including a discrete version of Gauss-Bonnet, Schläfli’s polyhedral formula, and the cotan Laplace operator—which will be the focus of our next set of lectures.

## Lecture 16—Discrete Curvature I (Integral Viewpoint)

Just as curvature provides powerful ways to describe and analyze smooth surfaces, discrete curvatures provide a powerful way to encode and manipulate digital geometry—and is a fundamental component of many modern algorithms for surface processing. This first of two lectures on discrete curvature from the integral viewpoint, i.e., integrating smooth expressions for discrete curvatures in order to obtain curvature formulae suitable for discrete surfaces. In the next lecture, we will see a complementary variational viewpoint, where discrete curvatures arise by instead taking derivatives of discrete geometry. Amazingly enough, these two perspectives will fit together naturally into a unified picture that connects essentially all of the standard discrete curvatures for triangle meshes.

## Assignment 3 [Coding]: The Laplacian (Due 4/22)

For the coding portion of this assignment, you will build the so-called “cotan-Laplace” matrix and start to see how it can be used for a broad range of surface processing tasks, including the Poisson equation and two kinds of curvature flow.

Getting Started

Please implement the following routines in

1. core/geometry.[cpp|js]:
• laplaceMatrix
• massMatrix
2. projects/poisson-problem/scalar-poisson-problem.[cpp|js]:
• constructor
• solve
3. projects/geometric-flow/mean-curvature-flow.[cpp|js]:
• buildFlowOperator
• integrate
4. projects/geometric-flow/modified-mean-curvature-flow.[cpp|js]:
• constructor
• buildFlowOperator

Notes

• Sections 6.4-6 of the course notes describe how to build the cotan-Laplace matrix and mass matrices, and outline how they can be used to solve equations on a mesh. In these applications you will be required to setup and solve a linear system of equations $Ax=b$ where $A$ is the Laplace matrix, or some slight modification thereof. Highly efficient numerical methods such as Cholesky Factorization can be used to solve such systems, but require A to be symmetric positive definite. Notice that the cotan-Laplace matrix described in the notes is negative semi-definite. To make it compatible for use with numerical methods like the Cholesky Factorization, your implementation of laplaceMatrix should instead produce a positive definite matrix, i.e., it should represent the expression
$$(\Delta u)_i=\frac12 \sum_{ij}(\cot \alpha_{ij}+\cot \beta_{ij})(u_i–u_j).$$(Note that $u_i−u_j$ is reversed relative to the course notes.) To make this matrix strictly positive definite (rather than semidefinite), you should also add a small offset such as $10^{-8}$ to the diagonal of the matrix (which can be expressed in code as a floating point value 1e-8). This technique is known as Tikhonov regularization.
• The mass matrix is a diagonal matrix containing the barycentric dual area of each vertex.
• In the scalar Poisson problem, your goal is to discretize and solve the equation $\Delta \phi = \rho$ where $rho$ is a scalar density on vertices and $\Delta$ is the Laplace operator. Be careful about appropriately incorporating dual areas into the discretization of this equation (i.e., think about where and how the mass matrix should appear); also remember that the right-hand side cannot have a constant component (since then there is no solution).
• In your implementation of the implicit mean curvature flow algorithm, you can encode the surface $f:M \to \mathbb R^3$ as a single DenseMatrix of size $|V| \times 3$, and solve with the same (scalar) cotan-Laplace matrix used for the previous part. When constructing the flow operator, you should follow section 6.6 of the notes. But be careful – when we discretize equations of the form $\Delta f = \rho$, we create systems of the form $A f = M \rho$. So you’ll need to add in the mass matrix somewhere. Also, recall that our discrete Laplace matrix is the negative of the actual Laplacian.
• The modified mean curvature flow is nearly identical to standard mean curvature flow. The one and only difference is that you should not update the cotan-Laplace matrix each time step, i.e., you should always be using the cotans from the original input mesh. The mass matrix, however, must change on each iteration.

Submission Instructions

Please only turn in the source files geometry.[cpp|js], scalar-poisson-problem.[cpp|js], mean-curvature-flow.[cpp|js] and modified-mean-curvature-flow.[cpp|js] . These files should be submitted via the usual mechanism, as described on the assignments page.

## Assignment 3 [Written]: The Laplacian (Due 4/22)

These exercises will lead you through two different derivations for the cotan-Laplace operator. As we’ll discuss in class, this operator is basically the “Swiss army knife” of discrete differential geometry and digital geometry processing, opening the door to a huge number of interesting algorithms and applications. Note that this time the exercises all come from the course notes—you will need to read the accompanying notes in order to familiarize yourself with the necessary material (we’ll cover some of this stuff in greater depth later on, but you don’t need it for the assignment!)

## Reading 6—The Laplace Operator (due April 15)

Your next reading covers one of the most fundamental objects in differential geometry, and one of the most useful objects in practical geometry processing: the Laplace-Beltrami operator $\Delta$, which we’ll often refer to as just the “Laplacian”. This operator generalizes the familiar Laplace operator $\Delta = \frac{\partial^2}{\partial x_1^2} + \cdots + \frac{\partial^2}{\partial x_n^2}$ from Euclidean $\mathbb{R}^n$ to general curved manifolds. Like the ordinary Laplacian, at a very basic level Laplace-Beltrami provides information about the “curvature” of a function. It also shows up in an enormous number of physical and geometric equations, and for this reason there has been intense study of different ways to discretize the Laplacian (not only for simplicial meshes, but also point clouds and other discrete surface representations).

The next written assignment will give you some essential background on the smooth Laplace operator. This reading will also expose you to some of the key issues to think about when designing a discrete Laplacian. For this reading, you can choose either of the following two papers:

You should not worry about deeply understanding all of the mathematical details in these papers; the point is just to get a sense of the issues at stake, and how these considerations translate into practical definitions of discrete Laplace matrices. The first paper, by Wardetzky et al, considers a “No Free Lunch” theorem for discrete Laplacians that continues our story of “The Game” played in discrete differential geometry. The second paper, by Bobenko & Springborn considers the important perspective of intrinsic triangulations of polyhedral surfaces, and uses this perspective to develop a Laplace operator that is well-behaved even for very poor quality triangulations. You should simply summarize the high-level ideas in these papers, and any questions you might have.

The reading is due on Thursday, April 15 at 10am Eastern time. Hand-in instructions are as usual described on the assignments page.

## Lecture 15: Curvature of Surfaces

Much of the geometry we encounter in everyday life (such as curves and surfaces sitting in space) is well-described by it curvatures. For instance, the fundamental theorem for plane curves says that an arc-length parameterized plane curve is determined by its curvature function, up to rigid motions. Similar statements can be made about surfaces and their curvatures, which we explore in this lecture.

## Lecture 14: Discrete Surfaces

We’ll follow up our lecture on smooth surfaces with a view of surfaces from the discrete point of view. Our goal will be to translate basic concepts (such as the differential, immersions, etc.) into a purely discrete language. Here we’ll also start to see the benefit of developing discrete differential forms: many of the statements we made about surfaces in the smooth setting can be translated into the discrete setting with minimal effort. As we move forward with discrete differential geometry, this “easy translation” will enable us to take advantage of deep insights from differential geometry to develop practical computational algorithms.

## Lecture 12: Smooth Surfaces I

This lecture takes a first look at smooth surfaces. There’s of course way more to know about surfaces than we can pack into a single lecture (and we’ll see plenty more later on), but this lecture will cover two very important perspectives: the extrinsic description of a surface via a local parameterization, which tells us where points sit in space, and the intrinsic description of a surface via coordinate charts, which lets us work with a surface without worrying how it’s embedded in space.

## Lecture 11: Discrete Curves

This lecture presents the discrete counterpart of the previous lecture on smooth curves. Here we arrive at a discrete version of the fundamental theorem for plane curves: a discrete curve is completely determined by its discrete parameterization (a.k.a. edge lengths) and its discrete curvature (a.k.a. exterior angles). We’ll also cook up a discrete version of the fundamental theorem for space curves, and give a bunch of neat examples of discrete curves in geometry processing and physical simulation.

## Reading 5—Curves and Surfaces (due 3/31)

Your next reading complements our in-class discussion of the geometry of curves and surfaces. In particular, you should read Chapter 3 of the course notes, pages 28–44. This reading is due next Wednesday, March 31.

Handin instructions are described on the Assignments Page.

Since these notes just barely scratch the surface (literally), I am often asked for recommendations on books that provide a deeper discussion of surfaces. The honest answer is, “I don’t know; I mostly didn’t learn it from a book.” But there are a couple fairly standard references (other) people seem to like, both of which should be available digitally from the CMU library:

## Assignment 2 (Coding): Investigating Curvature (Due 4/6)

For the coding portion of this assignment, you will implement various expressions for discrete curvatures and surfaces normals that you will derive in the written assignment. (However, the final expressions are given below in case you want to do the coding first.) Once implemented, you will be able to visualize these geometric quantities on a mesh. For simplicity, you may assume that the mesh has no boundary.

Getting Started
Please implement the following routines in core/geometry.[js|cpp]:

1. angle
2. dihedralAngle
3. vertexNormalAngleWeighted
4. vertexNormalSphereInscribed
5. vertexNormalAreaWeighted
6. vertexNormalGaussianCurvature
7. vertexNormalMeanCurvature
8. angleDefect
9. totalAngleDefect
10. scalarMeanCurvature
11. circumcentricDualArea
12. principalCurvatures

Notes

1. The dihedral angle between the normals $N_{ijk}$ and $N_{ijl}$ of two adjacent faces $ijk$ and $ijl$ (respectively) is given by
$$\theta_{ij} := \text{atan2}\left(\frac{e_{ij}}{\|e_{ij}\|} \cdot \left(N_{ijk} \times N_{jil}\right), N_{ijk} \cdot N_{jil}\right)$$

where $e_{ij}$ is the vector from vertex $i$ to vertex $j$.

2. The formulas for the angle weighted normal, sphere inscribed normal, area weighted normal, discrete Gaussian curvature normal and discrete mean curvature normal at vertex $i$ are
\begin{aligned} N_i^\phi &:= \sum_{ijk \in F} \phi_i^{jk}N_{ijk}\\ N_i^S &:= \sum_{ijk \in F} \frac{e_{ij} \times e_{ik}} {\|e_{ij}\|^2\|e_{ik}\|^2}\\ N_i^A &:= \sum_{ijk \in F} A_{ijk}N_{ijk}\\ KN_i &= \frac 12 \sum_{ij \in E} \frac{\theta_{ij}}{\|e_{ij}\|}e_{ij}\\ HN_i &= \frac 12 \sum_{ij \in E}\left(\cot\left(\alpha_k^{ij}\right) + \cot\left(\beta_l^{ij}\right)\right)e_{ij} \end{aligned}

where $\phi_i^{jk}$ is the interior angle between edges $e_{ij}$ and $e_{ik}$, and $A_{ijk}$ is the area of face $ijk$. Note that sums are taken only over elements (edges or faces) containing vertex $i$. Normalize the final value of all your normal vectors before returning them.

3. The circumcentric dual area at vertex $i$ is given by
$A_i := \frac 18 \sum_{ijk \in F} \|e_{ik}\|^2\cot\left(\alpha_j^{ki}\right) + \|e_{ij}\|^2\cot\left(\beta_k^{ij}\right)$

4. The discrete scalar Gaussian curvature (also known as angle defect) and discrete scalar mean curvature at vertex $i$ are given by
\begin{aligned} K_i &:= 2\pi – \sum_{ijk \in F} \phi_i^{jk}\\ H_i &:= \frac 12 \sum_{ij \in E} \theta_{ij}\|e_{ij}\| \end{aligned}

Note that these quantities are discrete 2-forms, i.e., they represent the total Gaussian and mean curvature integrated over a neighborhood of a vertex. They can be converted to pointwise quantities (i.e., discrete 0-forms at vertices) by dividing them by the  circumcentric dual area of the vertex (i.e., by applying the discrete Hodge star).

5. You are required to derive expressions for the principal curvatures $\kappa_1$ and $\kappa_2$ in exercise 4 of the written assignment. Your implementation of principalCurvatures should return the (pointwise) minimum and maximum principal curvature values at a vertex (in that order).

Submission Instructions

Please submit only the source code file geometry.js or geometry.cpp (depending on whether you’re using JavaScript or C++). This means your code should not depend on edits made to any other files. Then follow the usual hand-in instructions.

## Book Recommendation for Differential Forms

If anyone is seeking a more formal treatment of differential forms than the (admittedly informal!) description given in class, a good reference is

Abraham, Marsden, Ratiu, “Manifolds, Tensor Analysis, and Applications

Note that an electronic version of this book is available for free for CMU students through the library webpage.

A big difference from the treatment we’ve seen in class is that this book first spends several chapters defining and studying manifolds before introducing differential forms. We instead started with differential forms in $\mathbb{R}^n$, and will later talk about how to work with them on curves and surfaces. Interestingly enough, however, differential forms in $\mathbb{R}^n$ is essentially all we need to define discrete differential forms, which in turn are sufficiet to work with “curved” polyhedral surfaces. (The joys of being piecewise Euclidean…)

## Lecture 10: Smooth Curves

After spending a great deal of time understanding some basic algebraic and analytic tools (exterior algebra and exterior calculus), we’ll finally start talking about geometry in earnest, starting with smooth plane and space curves. Even low-dimensional geometry like curves reveal a lot of the phenomena that arise when studying curved manifolds in general. Our main result for this lecture is the fundamental theorem of space curves, which reveals that (loosely speaking) a curve is entirely determined by its curvatures. Descriptions of geometry in terms of “auxiliary” quantities such as curvature play an important role in computation, since different algorithms may be easier or harder to formulate depending on the quantities or variables used to represent the geometry. Next lecture, for instance, we’ll see some examples of algorithms for curvature flow, which naturally play well with representations based on curvature!

## Supplemental: Vector-Valued Differential Forms

This short-but-important supplemental lecture introduces some language we’ll need for describing geometry (curves, surfaces, etc.) in terms of differential forms. So far, we’ve said that a differential $k$-form produces a scalar measurement. But when talking about geometry, we often care about quantities that are vector-valued rather than scalar-valued. For instance, positions in $\mathbb{R}^n$, tangents, and normals are all vector-valued quantities. For the most part, all of our operations look pretty much the same as before. The one exception is the wedge product, which in $\mathbb{R}^3$ we now define in terms of the cross product.

## Lecture 9: Discrete Exterior Calculus

This lecture wraps up our discussion of discrete exterior calculus, which will provide the basis for many of the algorithms we’ll develop in this class. Here we’ll encounter the same operations as in the smooth setting (Hodge star, wedge product, exterior derivative, etc.), which in the discrete setting are encoded by simple matrices that translate problems involving differential forms into ordinary linear algebra problems.

## Lecture 8: Discrete Differential Forms

In this lecture, we turn smooth differential $k$-forms into discrete objects that we can actually compute with. The basic idea is actually quite simple: to capture some information about a differential $k$-form, we integrate it over each oriented $k$-simplex of a mesh. The resulting values are just ordinary numbers that give us some sense of what the original $k$-form must have looked like.

## Lecture 7: Integration

Our first lecture on exterior calculus covered differentiation; our second lecture completes the picture by discussing integration of differential forms. The relationship between integration and differentiation is encapsulated by Stokes’ theorem, which generalizes the fundamental theorem of calculus, as well as many other important theorems from vector calculus and complex analysis (divergence theorem, Green’s theorem, Cauchy’s integral formula, etc.). Stokes’ theorem also plays a key role in numerical discretization of geometric problems, appearing for instance in finite volume methods and boundary element methods; for us it will be the essential tool for developing a discrete version of differential forms that we can actually compute with.

• Video
• Slides
• ## Lecture 6: Exterior Derivative

Ordinary calculus provides tools for understanding rates of change (via derivatives), total quantities (via integration), and the total change (via the fundamental theorem of calculus). Exterior calculus generalizes these ideas to $n$-dimensional quantities that arise throughout geometry and physics. Our first lecture on exterior calculus studies the exterior derivative, which describes the rate of change of a differential form, and (together with the Hodge star) generalizes the gradient, divergence, and curl operators from standard vector calculus.

## Assignment 1 (Written): Exterior Calculus (Due 3/18)

The written portion of assignment 1 is now available, which covers some of the fundamental tools we’ll be using in our class. Initially this assignment may look a bit intimidating, but the homework is not as long as it might seem: all the text in the big gray blocks contains supplementary, formal definitions that you do not need to know in order to complete the assignments.

Don’t be shy about asking us questions here in the comments, via email, or during office hours.  We want to help you succeed on this assignment, so that you can enjoy all the adventures yet to come…

This assignment is due on Thursday, March 18.

## Assignment 1 (Coding): Exterior Calculus (Due 3/18)

For the coding portion of your first assignment, you will implement the discrete exterior calculus (DEC) operators $\star_0, \star_1, \star_2, d_0$ and $d_1$. Once implemented, you will be able to apply these operators to a scalar function (as depicted above) by pressing the “$\star$” and “$d$” button in the viewer. The diagram shown above will be updated to indicate what kind of differential k-form is currently displayed. These basic operations will be the starting point for many of the algorithms we will implement throughout the rest of the class; the visualization (and implementation!) should help you build further intuition about what these operators mean and how they work

Getting Started

• For this assignment, you need to implement the following routines:
1. in core/geometry.[js|cpp]
1. cotan
2. barycentricDualArea
2. in core/discrete-exterior-calculus.[js|cpp]
1. buildHodgeStar0Form
2. buildHodgeStar1Form
3. buildHodgeStar2Form
4. buildExteriorDerivative0Form
5. buildExteriorDerivative1Form

In practice, a simple and efficient way to compute the cotangent of the angle $\theta$ between two vectors $u$ and $v$ is to use the cross product and the dot product rather than calling any trigonometric functions directly; we ask that you implement your solution this way. (Hint: how are the dot and cross product of two vectors related to the cosine and sine of the angle between them?)

In case we have not yet covered it in class, the barycentric dual area associated with a vertex $i$ is equal to one-third the area of all triangles $ijk$ touching $i$.

EDIT: You can compute the ratio of dual edge lengths to primal edge lengths using the cotan formula, which can be found on Slide 28 of the Discrete Exterior Calculus lecture, or in exercise 36 of the notes (you don’t have to do the exercise for this homework).

Submission Instructions

Please submit your geometry.[js|cpp] and discrete-exterior-calculus.[js|cpp] files to Gradescope.  You should not submit any other source files (and therefore, should not edit any other source files to get your code working!).

## Reading 4: Exterior Calculus — due 3/11

The next reading assignment will wrap up our discussion of exterior calculus, both smooth and discrete. In particular, it will explore how to differentiate and integrate $k$-forms, and how an important relationship between differentiation and integration (Stokes’ theorem) enables us to turn derivatives into discrete operations on meshes. In particular, the basic data we will work with in the computational setting are “integrals of derivatives,” which amount to simple scalar quantities we can associate with the vertices, edges, faces, etc. of a simplicial mesh. These tools will provide the basis for the algorithms we’ll explore throughout the rest of the semester.

The reading is the remainder of Chapter 4 from the course notes, “A Quick and Dirty Introduction to Exterior Calculus”, Sections 4.6 through 4.8 (pages 67–83). Note that you just have to read these sections; you do not have to do the written exercises; a different set of written problems will be posted later on. The reading is due Thursday, March 11 at 10am. See the assignments page for handin instructions.

## Lecture 4: $k$-Forms

Today we continue our journey toward building up (discrete) exterior calculus by talking about how to measure little k-dimensional volumes. Just like rulers measure length, and cups measure volume, k-forms will be used to take measurements of the little k-dimensional volumes or k-vectors that we built up using exterior algebra in our previous lecture. Such measurements will ultimately allow us to talk about integration over curved spaces; in the discrete setting, these measurements will be the basic data we associate with the elements of mesh.

## Reading 3: Exterior Algebra and k-Forms (due 3/2)

Your next reading assignment will help you review the concepts we’ve been discussing in class: describing “little volumes” or $k$-vectors using the wedge product and the Hodge star, and measuring these volumes using “dual” volumes called $k$-forms. These objects will ultimately let us integrate quantities over curved domains, which will also be our main tool for turning smooth equations from geometry and physics into discrete equations that we can actually solve on a computer.

The reading is Chapter 4, “A Quick and Dirty Introduction to Exterior Calculus”, up through section 4.5.1 (pages 45–65). It will be due Tuesday, March 2 at 10am Eastern time. See the assignments page for handin instructions.

Your next homework will give you some hands-on practice with differential forms; just take this time to get familiar with the basic concepts.

## Recitation: halfedges, sparse linear systems, intro to coding assignments

This is a short video recitation from the TAs reviewing how the halfedge data structure, sparse matrices, and solving linear systems will be used in the course assignments. We’ve also included information on how to get started with both the Javascript and C++ versions of the coding assignments.

You can find the full video below (or watch just a portion), as well as the slides.

## Lecture 3: Exterior Algebra

Our next lecture will cover one of the basic tools we’ll use throughout the rest of the course: exterior algebra. The basic idea is to add a couple new operations to our usual list of vector operations (dot product, cross product, etc.) that make it easy to talk about volumes rather than just vectors. If you felt ok working with things like the cross product and the determinant in your linear algebra/vector calculus courses, this shouldn’t be too big of a leap. (If not, could be a good moment for a review!)

## Lecture 2B: Introduction to Manifolds

In tomorrow’s lecture we will catch a first glimpse of the idea of manifolds, which are pretty central to differential geometry. Rather than giving a formal definition in the smooth case, we’ll introduce a notion of discrete manifolds that capture the most important ideas. These discrete manifolds build on the idea of a simplicial complex, introduced in the previous lecture.

## Reading 2: Combinatorial Surfaces (Due 2/19)

Your next reading will take a dive into purely combinatorial descriptions of surfaces, i.e., those that capture connectivity, but not geometry.  These descriptions and data structures will provide the foundation for all the geometry and algorithms we’ll build up in this class.  (The reading also provides the essential background for your first written and coding assignments!)

The reading is Chapter 2, pages 7–20 of our course notes, which can always be accessed from the link above.

Your short 2-3 sentence summary is due by 10am Eastern on February 19, 2020.  Handin instructions can be found on the assignment page.

## Assignment 0 (Coding): Combinatorial Surfaces — due 2/26

For the coding portion of your first assignment, you will implement some operations on simplicial complexes which were discussed in class and in Chapter 2 of the course notes. Once implemented, you will be able to select simplices and apply these operations to them by clicking the appropriate buttons in the viewer (shown above).

Getting Started

• Decide whether you want to use the web skeleton (in JavaScript) or the desktop skeleton (in C++). The web skeleton should “just work” for anyone with a web browser. Setting up the C++ skeleton is also fairly automatic (just a few git commands), but requires a little more familiarity with coding environments. (The benefit of the C++ version is that it’s built on a richer, real-world mesh processing/visualization library than the web version.)
• To use the JavaScript version, download or clone the files in the ddg-exercises-js repository.
• To use the C++ version, follow the instructions in the ddg-exercises repository. It is important that you follow the “Getting Started” instructions and do not simply git clone the repo. Otherwise, dependencies will not be installed correctly, and the code will not build. If you struggle to get the C++ version working on your platform, we recommend you switch to the JavaScript version.
• Either way, you should need to download just one code skeleton for the whole semester (though we may push periodic updates to fix bugs, etc.).
• For this assignment, you will need to implement the following routines in projects/simplicial-complex-operators/simplicial-complex-operators.[js|cpp]:
• assignElementIndices
• buildVertexVector
• buildEdgeVector
• buildFaceVector
• star
• closure
• isComplex
• isPureComplex
• boundary

Notes

• The JavaScript assignment comes with a viewer projects/simplicial-complex-operators/index.html which lets you apply your operators to simplices of meshes and visualize the results. Likewise, the C++ version comes with a viewer with similar functionality. (Viewers will be available for all assignments throughout the semester.)
• Pay close attention to the course notes! Some routines really must be implemented with sparse matrices, not directly with the halfedge mesh data structure.
• Selecting simplices will not work until you fill in the assignElementIndices function.
• The assignment also comes with a test script tests/simplicial-complex-operators/text.html which you can use to verify the correctness of your operators.
• The web framework is implemented in Javascript, which means no compilation or installation is necessary on any platform. You can simply get started by opening the index.html file in projects/discrete-exterior-calculus/ in a web browser. We recommend using Chrome or Firefox. Safari has poor WebGL performance.
• If you do not have prior experience with Javascript, do not worry! You should be able to get a handle on Javascript syntax by reading through some of the code in the framework (a good place to start might be core/geometry.js). The framework also contains extensive documentation (see docs/index.html).
• All browsers come with tools for debugging (for instance the JavaScript Console in Chrome).

Submission Instructions

The assignment is due on February 26, 2020 at 5:59:59pm Eastern (not at midnight!). Remember to turn in the whole coding assignment via a single ZIP file containing the modified source files. Further hand-in instructions can be found on this page.

## Assignment 0 (Written): Combinatorial Surfaces — due 2/26

For the written part of your first homework you will do some exercises that will help familiarize you with basic descriptions and representations of combinatorial surfaces (simplicial surfaces, adjacency matrices, halfedge meshes), which will help prepare you to work with such surfaces as we continue through the course. (If any of this stuff seems abstract right now, don’t worry: we’ll use it over and over again to implement “real” algorithms starting in just a couple weeks!)

You must complete all 15 exercises from the Written Exercises section of Chapter 2 of the course notes. If these exercises seem scary and unfamiliar, and you don’t know where to start, that’s ok! This is not typical computer science stuff, and you shouldn’t necessarily know how to do it right off the bat. If you find yourself stumbling, please reach out to the instructor/TAs and your classmates on Piazza, Discord, or during the office hours/Q&A sessions. We’ll have you up and running in no time. 🙂

The assignment is due on February 26, 2021 at 5:59:59pm Eastern (not at midnight!). Hand-in instructions can be found on this page.

## Reading 1: Overview of DDG (Due 2/11)

Due date: 10am Eastern on Thursday, February 11, 2021

Your first reading assignment will be to read an overview article on Discrete Differential Geometry. Since we know we have a diverse mix of participants in the class, you have several options (pick one):

1. (pages 1–3) Crane & Wardetzky, “A Glimpse into Discrete Differential Geometry”.
2. (pages 1–5) Pottman et al, “Architectural Geometry”.
This article discusses the beautiful tale of how discrete differential geometry is linked to modern approaches to computational design for architecture, as well as fabrication and “rationalization” of free-form designs.
3. (pages 5–9) Bobenko & Suris, “Discrete Differential Geometry: Consistency As Integrability”.
This article provides another overview of discrete differential geometry, with an emphasis on nets and their connection to the notion of integrability in geometry and physics.

Though written for a broad audience, be warned that all of these articles are somewhat advanced—the goal here is not to understand every little detail, but rather just get a high-level sense of what DDG is all about.

Assignment: Pick one of the readings above, and write 2–3 sentences summarizing what you read, plus at least one question about something you didn’t understand, or some thought/idea that occurred to you while reading the article.  For this first assignment, we are also very interested to know a little bit about YOU! E.g., why are you taking this course?  What’s your background?  What do you hope to get out of this course?  What are your biggest fears about the course?  Etc.

Handin instructions can be found in the “Readings” section of the Assignments page.

Enjoy!

## Lecture 1: Overview

Our first lecture provides motivation for the topics we’ll cover in the course, and takes a deep dive into one specific example (curvature of curves in the plane) to highlight some of the basic principles of discrete differential geometry. This example moves pretty fast and uses some ideas that we’ll study at a slower, more careful pace later on. For now, don’t worry too much about the details—the goal here is to just get a sense of what the course is all about!

## Assignment -1: Favorite Formula

Part of your course grade is determined by participation, which can include both in-class participation as well as discussion here on the course webpage.  Therefore, your first assignment is to:

1. create an account (you must use your Andrew email address, so we can give you participation credit this semester!),
To make things interesting, your comment should include a description of your favorite mathematical formula typeset in $\LaTeX$.  If you don’t know how to use $\LaTeX$ this is a great opportunity to learn — a very basic introduction can be found here.  (And if you don’t have a favorite mathematical formula, this is a great time to pick one!)

(P.S. Anyone interested in hearing about some cool “favorite theorems” should check out this podcast.)

## Welcome to Discrete Differential Geometry! (Spring 2021)

Welcome to the website for 15-458/858 (Discrete Differential Geometry).  Here you’ll find course notes, lecture slides, and homework (see links on the right).

If you are a student in the class, register now by clicking here!

To participate in the class, you must register using your Andrew (CMU) email address.

A few things to note:

• You can include mathematical notation in your questions using standard $\LaTeX$ syntax.  For instance, when enclosed in a pair of dollar signs, an expression like \int_M K dA = 2\pi\chi gets typeset as $\int_M K dA = 2\pi\chi$.