• April 11th: Project ideas on Piazza (optional).
• April 11th: Project proposal PDF due on Canvas.
• May 9th (1 - 4 pm ET, in person at BH A36): Project presentations and rendering competition in class.
• May 12th: Project report PDF due on Canvas, code due on GitHub.

Teams: Final projects must be done individually, there is no option to work in teams.

Renderers: For your final project, you can work with one of the following renderers:

• DIRT, the renderer we use for programming assignments.
• Mitsuba 0.6, a research-oriented renderer with support for a rich class of rendering algorithms and scenes.

If you choose to use Mitsuba, your project proposal should justify this use. For example, if you want to experiment with modifications to some advanced rendering algorithm like Metropolis light transport, it is better to do so on Mitsuba. If you want to add support for new material classes, you should do that on DIRT.

Scope of final projects: Your final project should focus on implementing a set of features on top of either of the above renderers. We will broadly group implemented features into three categories:

• Simple features worth up to 2 points each (e.g., implementing a new type of light source or sensor, adding new BRDF models).
• Intermediate features worth up to 6 points each (e.g., adding polarization support, adding time-of-flight support).
• Advanced features worth up to 10 points each (e.g., implementing bidirectional path tracing, adding specular next-event estimation).

Your project should comprise a list of features that sum up to at least 12 points. You can implement features for additional points for extra credit, e.g., to make up for credit you missed in programming assignments and quizzes, or for an A+ grade. Additionally, the list should include at least one intermediate or advanced feature. The above point breakdowns are just a rough guide. For each implemented feature, your project should produce:

• Feature-specific renderings showcasing a scene that emphasize's the feature's effect.
• Technical details of the implementation.
• Tests performed to validate correctness, and their results.
• Code, comments, and documentation for the feature's implementation.

In addition to the above, your final project should include a visually compelling rendering of a new scene that you put together to showcase all of the features you implemented. This image will serve as your entry to the rendering competition.

Each student will post on Piazza a list of features they are considering implementing, as well as a proposed categorization (simple, intermediate, advanced) and number of points for each feature. Please make sure to make your post private and assign it to the final project folder. The teaching staff will follow up on the posts, with feedback on each proposed feature (whether it is correctly categorized, whether it is too simple or too ambitious given the project timeline, and so on). We encourage you to submit a feature list summing up to more than the required 12 points, so that you have more options for your eventual project proposal.

Coming up with project ideas: Below are a few pointers that can help you come up with ideas. You should also take advantage of office hours between now and the due dates for your proposal, to discuss potential final project topics with the teaching staff.

• After each lecture, the teaching staff post on Slack pointers to papers and other material that relate to the lecture's overall theme, as well as more advanced topics not covered during the lecture. You can follow up on those pointers.
• If the overall theme of some lecture strongly appealed to you, you can do a literature search to find more recent papers in that area, and peruse those for ideas. Good starting points for your literature search are the related sections in the PBRT and AGI textbooks, as those almost always discuss key recent advances and papers. Google Scholar is also your friend, especially the option to show citations of a paper, which you can use to search through recent research on topics and papers we discuss in class lectures.
• You can look at projects and renderings from the previous offering of this course.
• You can look at results from rendering competitions in similar courses offered elsewhere. A list of such courses is available at the bottom of the course's main page.

Below are some pointers to specific topics that the teaching staff find intriguing, and associated literature. Most of the below-listed topics would correspond to intermediate and advanced features.

• Advanced integrators: bidirectional path tracing, Metropolis light transport, primary sample space.
• BSDF models: energy conserving microfacet models, data-driven BRDF models.
• Coherent rendering: speckle effects, diffractive effects.
• Computational light transport: integrators for epipolar and disparity probing.
• Cloth, fur, and hair: see works in this area by Steve Marschner and Ravi Ramamoorthi.
• Differentiable rendering: differentiating local parameters and global parameters, path-space differentiable rendering.
• Eikonal rendering: eikonal rendering, refractive radiative transfer equation.
• Layered materials: layer lab, layering with statistical operators, position-free Monte Carlo, pearlescent materials.
• Lenses: ray tracing complex optics, depth of field effects.
• Lightfield: rendering plenoptic cameras.
• Luminaires: complex luminaires.
• Non-exponential radiative transfer: path-tracing algorithms.
• Polarization: bidirectional algorithms.
• Spectral rendering: spectral tracking.
• Specular and glints: specular next-event estimation, slope-space integrals.
• Temporal blur: H2MC.
• Time of flight: photon mapping techniques, ellipsoidal connections.
• Volumes, transmittance, and phase functions: null-space path integral, integral formulations of transmittance, Mie theory material models, perceptually-uniform phase functions, microflake phase functions, anisotropic radiative transfer.

The written project proposal should be a PDF of size between 1-2 pages, to be submitted on Canvas. It should:

• mention explicitly and provide justification for what renderer you plan to use;
• have a detailed list of the features you plan to implement, their categorization, and corresponding points;
• cite all related literature; and
• include a tentative schedule for your project.

There are four final deliverables for your project: A project presentation, an image submission for the rendering competition, a project report, and the project code.

Project presentation and rendering competition image (May 9th, 1 - 4 pm ET, in person at BH A36): Project presentations will happen during a special class session scheduled during the exam period. Each presentation will last for four minutes, with two and a half more minutes for questions from the teaching staff and other students. Time limits will be strictly enforced! Therefore, you should make sure to prepare and practice your presentation in advance. You should prepare as many slides as you think you need for the minutes you have (we recommend one slide per minute). Your presentation should include your image submission for the rendering competition. We will decide the winners of the competition at the end of the project presentation session.

Project report and code (May 12th): Your final report, to be submitted on Canvas, should be a PDF, typeset on LaTeX, elaborating on the evaluation elements described above, for each of the features you implemented. Your code should be submitted through GitHub classroom.

A lot of this write-up is inspired from Kayvon Fatahalian's final project instructions for 15-769: Visual Computing Systems, and from Wojciech Jarosz's final project instructions for Rendering Algorithms at Dartmouth College.