3D graphics eBook - Course Materials Repository

Path tracing 99
}
Color reflected = TracePath(newRay,depth+1);
return emittance + ( BDRF * cos_omega * reflected );
In the above example if every surface of a closed space emitted and reflected (0.5,0.5,0.5) then every pixel in the
image would be white.
Bidirectional path tracing
In order to accelerate the convergence of images, bidirectional algorithms trace paths in both directions. In the
forward direction, rays are traced from light sources until they are too faint to be seen or strike the camera. In the
reverse direction (the usual one), rays are traced from the camera until they strike a light or too many bounces
("depth") have occurred. This approach normally results in an image that converges much more quickly than using
only one direction.
Veach and Guibas give a more accurate description veach1997metropolis :
These methods generate one subpath starting at a light source and another starting at the lens, then they
consider all the paths obtained by joining every prefix of one subpath to every suffix of the other. This
leads to a family of different importance sampling techniques for paths, which are then combined to
minimize variance.
Performance
A path tracer continuously samples pixels of an image. The image starts to become recognisable after only a few
samples per pixel, perhaps 100. However, for the image to "converge" and reduce noise to acceptable levels usually
takes around 5000 samples for most images, and many more for pathological cases. This can take hours or days
depending on scene complexity and hardware and software performance. Newer GPU implementations are
promising from 1-10 million samples per second on modern hardware, producing acceptably noise-free images in
seconds or minutes. Noise is particularly a problem for animations, giving them a normally-unwanted "film-grain"
quality of random speckling.
Metropolis light transport obtains more important samples first, by slightly modifying previously-traced successful
paths. This can result in a lower-noise image with fewer samples.
Renderer performance is quite difficult to measure fairly. One approach is to measure "Samples per second", or the
number of paths that can be traced and added to the image each second. This varies considerably between scenes and
also depends on the "path depth", or how many times a ray is allowed to bounce before it is abandoned. It also
depends heavily on the hardware used. Finally, one renderer may generate many low quality samples, while another
may converge faster using fewer high-quality samples.