CS 6620.001 "Ray Tracing for Graphics" Fall 2014
Welcome to my ray tracing site for the course CS 6620.001, being taught at the University of Utah in Fall 2014 by Cem Yuksel.
Welcome fellow students! I have lots of experience tracing rays, and with graphics in general, and so I'll be pleased to help by giving constructive tips throughout (and I'll also try very hard to get the correct image, or say why particular images are correct as opposed to others). If you shoot me an email with a link to your project, I'm pretty good at guessing what the issues in raytracers are from looking at wrong images.
Hardware specifications, see bottom of page.
Timing information will look like "(#t #s ##:##:##)" and corresponds to the number of threads used, the number of samples (per pixel, per light, possibly explained in context), and the timing information rounded to the nearest second.
Project 12 - "Path Tracer"
My raytracer has been doing path tracing for a very long time. Moreover, the same for importance sampling. Gamma correction is subsumed in proper colorimetry; the image is being corrected for perception (using gamma-like functions, among other things) according to the updated sRGB standard. I implemented light tracing a long time ago, but it's not presentable now. I used most of the time to work on my final project (which is going to require some extra attention, since it's going to be complex).
I used some of the time to steal^H^H^H^H^Hgraciously borrow an idea for a better implementation of a framebuffer from Will Usher (whose raytracer is very nice, and quite faster than mine).
The idea is something I kindof thought of before, but dismissed: simply, each area keeps a list of samples while it's rendering (this is necessary to compute the estimator variance), but otherwise the general procedure is to splat the sample into all of the pixels it affects and then forget about it. The major problems with this are that the colorimetry needs to be evaluated once for each sample (instead of once for each pixel; in-practice this effect looks interesting while rendering) and that there's a penalty for atomicity that gets worse with more samples. I think this way is somewhat-less-wasteful than having dedicated reconstruction and deallocation threads, and it has the major, major advantage in my book of being simpler.
I decided to set up just a few scenes, since I'm working on actually improving the thing instead. Here's a glossy Cornell box with a glass bunny (16t 64,^0s 01:49:05):

\(64\) samples is clearly not enough.
One thing to notice is that everything looks all wonky. I realized in retrospect that this is partially caused by my BRDFs conserving energy. This has my normalization term that prevents the specular BRDF from losing extra energy, so bounces are quite strong. Try to think of this box as being made out of colored aluminum foil.
The weirdest part is the bright area in the bottom left. This is light bouncing off the far side of the bunny, hitting either the wall or the floor, then hitting the floor or the wall, and then going to the eye—in other words, it's a double-reflected caustic. That's also why it looks symmetrical.
Here's Lucy (forgot to bump her poly count). I changed the floor, walls, and ceiling back to diffuse so that it's easier to see what's going on, but this reduces the effect (16t 16,^0s 00:03:16):

So, I removed the glossiness on the colored surfaces and put it on the white surfaces with a higher exponent (16t 16,^0s 00:03:08):

Lucy appears so bright here because much of the energy is reflected down into the base, off the floor specularly, and then back up into her. This is definitely a candidate for more samples!
The model here is a higher-resolution one; Lucy is less polygonal, and so reflects less light in sharp ways. This accounts for the major qualitative difference (16t 512,^0s 07:17:26):

Rather pretty, methinks.
Proceed to the Previous Project or Next Project.
Hardware
Except as mentioned, renders are done on my laptop, which has:
- Intel i7-990X (12M Cache, [3.4{6|7},3.73 GHz], 6 cores, 12 threads)
- 12 GB RAM (DDR3 1333MHz Triple Channel)
- NVIDIA GeForce GTX 580M
- 750GB HDD (7200RPM, Serial-ATA II 300, 16MB Cache)
- Windows 7 x86-64 Professional (although all code compiles/runs on Linux)