Image Synthesis Assignment 1: Heightfield Intersection

Due: February 8

Description

For this assignment, you will improve pbrt's support for rendering terrain in scenes like landscapes and seascapes. Terrain is often represented as an elevation map, or what we will call a heightfield: a 2D table indicating the height of a surface above each point of a uniform grid. In other words, a heightfield is tabulated form of a height function z(x,y) stored in a 2D array.

pbrt has no native support for rendering directly from heightfield data. Instead, it converts heightfields into triangle meshes by connecting adjacent height values in the array. This approach is general but relatively inefficient; by converting to triangles we lose the orderly structure of the heightfield, which can be exploited to render more efficiently. Your assignment is to apply techniques similar to those used for grid-based acceleration structures to develop a fast intersection routine for heightfields.

Step 1

Click here to download a zip file containing several pbrt scene files, heightfield data, and textures. The UNIX version of pbrt should build the heightfield shape plugin by default. If you're using windows, copy the heightfield.vcproj file to pbrt/win32/Projects/ and add the project file in the pbrt solution. After you have built the heightfield plugin, run pbrt on scenes: hftest.pbrt and landsea-0.pbrt, and you should see output images (hftest.exr and landsea-0.exr) that look like this:

The 4x4 heightfield in hftest.pbrt (left image) is designed for debugging; use this file as you develop and test your intersection algorithm. The landsea-0.pbrt contains two 64x64 heightfields (land and sea) and there are several views of this scene (0-3). landsea-big.pbrt contains a 1000x1000 heightfield and will likely take a while to render and consume loads of memory in the process.

Step 2

Write a new accelerator class that simply puts all primitives into a list and tests each ray against every primitive. Run a few sample scenes through your accelerator and report timing comparisons against the ones provided with pbrt. Present your results as a table of timings, but of course you should make sure that your "accelerator" produces correct images.

The purpose of this step is to provide a baseline for comparison; the provided accelerators in pbrt are already very fast. You should be able to do better than them by exploiting the special structure of heightfields, but nonetheless you should have something slow to compare against!

Step 3

Your assignment is to write a fast heightfield intersection algorithm, which will allow you to render higher resolution terrains more quickly than the current implementation. You should do this by modifying the existing 'pbrt/shapes/heightfield.cpp' file; you do not need to change other pbrt files. Specifically, you need to:

• Add and implement Intersect() and IntersectP() functions, which will allow the renderer to intersect a ray directly with the heightfield.
• Change CanIntersect to return true, so that pbrt uses your functions instead of the Refine method to convert to a triangle mesh.

Your implementation of Intersect() and IntersectP() will likely use an acceleration structure like a uniform grid or kd-tree. You should start by reading this paper on a fast method for marching rays through uniform grids. Also feel free to peruse the pbrt source for examples, but make sure you understand any code that you borrow.

Step 4

Once you have the fast intersection routines working, add the following additional features:

• Compute the u and v coordinates so that you can texture map heightfields. You can test this by rendering the texture.pbrt scene, which maps the land heightfield with a colored grid texture.
• Perform Phong interpolation of the normals across each heightfield triangle. See the text book for information about Phong interpolation.

Here are some example images of what you should see after completing the steps above:

Suggestions

• Make sure you understand how pbrt deals with transformations (e.g. object-to-world)
• You should understand the GetShadingGeometry() function and how it's used by the integrator to shade an intersection point. You will need to implement this as a member function in the heightfield class (for Step 3).
• It will probably be difficult for your algorithm to out perform pbrt, which uses a highly optimize 3D kd-tree to render triangle meshes. However, you should try to make your code as fast as possible.

Submission

Write a web page and mail the URL to the TA.. The page should contain the following:

• The timing results from step 1.
• A brief description of the algorithm(s) you implemented in steps 3 and 4.
• A link to your new accelerator source code
• A link to your modified heightfield.cpp file
  
• Two renderings of landsea-0.pbrt: one with Phong interpolated normals and one without.
• Renderings of scene files landsea-0.pbrt, landsea-1.pbrt, landsea-2.pbrt, and texture.pbrt, with Phong interpolation if you have it.
• A rendering of landsea-big.pbrt, which contains a 1000x1000 sea heightfield. This should be a good stress test for your algorithm.
• Timing comparisons for your heightfield scenes. This should include:
  • The original (provided) brute force calculations with your accelerator from step 1
  • The original (provided) brute force calculations with the kd-tree
  • The original (provided) brute force calculations with the uniform grid
  • Your fast intersector with your accelerator from step 1
  • Your fast intersector with the kd-tree
  • Your fast intersector with the regular grid
• A short discussion of what you found in your final timing experiments. Did anything surprise you? Were you able to beat pbrt's built-in accelerators?

Grading

This homework will be graded according to the following system:

0 - Little or no work was done
* - Significant effort was put into the assignment, but rendering does not work fully
** - The intersection routine was functionally complete, but step 3 doesn't work at all.
*** - Intersection and texture mapping worked, but normal interpolation didn't.
**** - Intersection and normal interpolation worked, but texture mapping didn't.
***** - All requirements satisfied, and the implementation is faster than the original

Note that only ONE star is available for intersection routines that aren't functional from all viewpoints, regardless of texture mapping and/or normal interpolation.