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 (though actually we’ve covered much of this stuff in class already!)
Author: Hossein
Reading 5—Curves and Surfaces (due 3/16)
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 Thursday, March 16.
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 (Written): Investigating Curvature (Due 3/21)
Assignment 2 (Coding): Investigating Curvature (Due 3/21)
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]:
- angle
- dihedralAngle
- vertexNormalAngleWeighted
- vertexNormalSphereInscribed
- vertexNormalAreaWeighted
- vertexNormalGaussianCurvature
- vertexNormalMeanCurvature
- angleDefect
- totalAngleDefect
- scalarMeanCurvature
- circumcentricDualArea
- 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.
The assignment is due on the date listed on the calendar, at 5:59:59pm Eastern (not at midnight!). Further hand-in instructions can be found on this page.
Assignment 1 (Written): Exterior Calculus (Due 2/28)
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.
Finally, 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 Tuesday, February 28 at 5:59:59pm Eastern (not at midnight!).
Assignment 1 (Coding): Exterior Calculus (Due 2/28)
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:
- in core/geometry.[js/cpp]
- cotan
- barycentricDualArea
- in core/discrete-exterior-calculus.[js/cpp]
- buildHodgeStar0Form
- buildHodgeStar1Form
- buildHodgeStar2Form
- buildExteriorDerivative0Form
- buildExteriorDerivative1Form
- in core/geometry.[js/cpp]
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!).
The assignment is due on the date listed on the calendar, at 5:59:59pm Eastern (not at midnight!). Further hand-in instructions can be found on this page.
Reading 4: Exterior Calculus — due 2/16
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, February 16 at 10am. See the assignments page for handin instructions.
Reading 3: Exterior Algebra and k-Forms (due 2/9)
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 Thursday, February 9 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: Getting started with the coding assignments
Here is a nice recording of the recitation session from earlier years.
This serves as a review on the halfedge data structure, working with sparse matrices and solving linear systems.
Full video and slides are available here:
- Full video
- Concept review (0:00 – 16:58)
- Intro to ddg-exercises-js (16:58 – 23:22)
- Intro to ddg-exercises (C++) (23:22 – 31:41)
- Slides