**Note:** This assignment is **NOT** required! However, you can complete it for up to 15% extra credit. Or, you can do this one instead of some of the other assignments. 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). Also, you *cannot* use late days on this assignment since it’s the last one.

Please implement the following routines in:

`projects/vector-field-decomposition/tree-cotree.js`:`buildPrimalSpanningTree``inPrimalSpanningTree``buildDualSpanningCotree``inDualSpanningCotree``buildGenerators`

`projects/vector-field-decomposition/harmonic-bases.js`:`buildClosedPrimalOneForm``compute`

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

**Hodge Decomposition**: Please implement the following routines in

`projects/vector-field-decomposition/hodge-decomposition.js`:`constructor``computeExactComponent``computeCoExactComponent``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:**

- I made some changes to the tests for this assignment, and to the trivial connections viewer. You should update the following files before starting the assignment:
`tests/vector-field-decomposition/test.html``tests/vector-field-decomposition/test.js``tests/direction-field-design/sphere.js``tests/direction-field-design/test.html``tests/direction-field-design/test.js``projects/direction-field-design/index.html`

- 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 rename all `js` files you edited to be `txt` files and put them in a **single zip file** called solution.zip. This file **and** your solution to the written exercises should be submitted together in a **single email** to Geometry.Collective@gmail.com with the subject line **DDG19A6**.

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

**Note:** This assignment is **NOT** required! However, you can complete it for up to 15% extra credit. Or, you can do this one instead of some of the other assignments. 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). 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.

Do any **12** of Exercise 8.1 – Exercise 8.21 in the notes, except for Exercise 8.13.

**Submission Instructions.** Please submit your solutions to the exercises (whether handwritten, LaTeX, etc.) as a single PDF file by email to Geometry.Collective@gmail.com. *This email must also contain the .zip file for your coding solution*. Scanned images/photographs can be converted to a PDF using applications like Preview (on Mac) or a variety of free websites (e.g., http://imagetopdf.com). Your submission email must include the string **DDG20A6** in the subject line.

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

Enjoy!

]]>Our final lecture for the term focuses 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

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:

`projects/geodesic-distances/heat-method.js`:`constructor``computeVectorField``computeDivergence``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**

Please rename your `heat-method.js` file to `heat-method.txt` and put it in a **single zip file** called solution.zip. This file **and** your solution to the written exercises should be submitted together in a **single email** to Geometry.Collective@gmail.com with the subject line **DDG20A5**.

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.

Note that for handin you should use **DDG20A5**, not **DDG19A5** (as stated in the PDF).

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

]]>`core/geometry.js`:`complexLaplaceMatrix`

`projects/parameterization/spectral-conformal-parameterization.js`:`buildConformalEnergy``flatten`

`utils/solvers.js`:`solveInversePowerMethod``residual`

**Notes**

- I added a few tests for
`utils/solvers.js`. They’re available in the git repository. If you’re familiar with git, you can pull the changes. If you’d prefer not to mess around with git, you can also just download the files and put them in`tests/utils`.**Warning:**I fixed a problem with the residual test. In the notes, the residual is defined as a 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^* A x}{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 has a`boundaries`variable which stores all the boundary loops. - The
`flatten`function returns a dictionary mapping each vertex to a vector (`linear-algebra/vector.js`) 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**

Please rename your `geometry.js`, `spectral-conformal-parameterization.js` and `solvers.js` files to `geometry.txt`, `spectral-conformal-parameterization.txt` and `solvers.txt` (respectively) and put them in a **single zip file** called solution.zip. These files **and** your solution to the written exercises should be submitted together in a **single email** to Geometry.Collective@gmail.com with the subject line **DDG20A4**.

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.

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

]]>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, before lecture on April 18, 2019**.