Whitted Ray Tracing

My rendering experience at computer took off with the implementation of the whitted ray tracer. I pulled out the skeleton frame-work from the Lund Graphics Group. The intention is to write maintainable code structures that generate photo-realistic images. The skeleton came along with all the basic and convenient utility classes like - Vector, Matrix, Point, Color, Image, etc. It follows the right handed coordinate system and it also gives the option to load/save image in both .png and .exr format.
The initial incarnation of the of the ray tracer is only capable of shooting eye rays and detecting if they hit any spheres in the scene or not.

I would like to give a small over view of some of the utility classes that came along with the skeleton.

• Color - It represents the RGB color value. Each color component (r,g,b) is stored as a float and it  is not limited to any specific range since we shall be working with the high-dynamic range images. The most basic arithmetic operations have been implemented, so that two colors can be added, multiplied, etc simply by: c1 - c2, c1 * c2, etc. All the arithmetic operations work element-wise.
• Vector - It represents a vector  direction in 3D space. Intuitive  math operations are implemented.
• Point - It represent a position in 3D space.
• Ray - The basic utility class in any ray tracing  operation.It contains some of the above mentioned class objects as members. The origin of the ray is represented by Point and direction of the ray is represented by Vector. 

Ray structure
Image courtesy by:
Lund Graphics Group

• Scene  - All the objects in the 3D world is represented by this class. These objects include the following:



Scene Representation
Image courtesy by:
Lund Graphics Group

• Primitives.
• Light sources.
• Cameras.

All of the above mentioned objects  are added to the scene with the add() function and internally stored in a scene graph. Before any operation can be performed on the scene, the prepare() function should be called. This function prepares the scene hierarchy for rendering by computing all the transformation matrices, setting up the acceleration data structure, and caching necessary data. A ray can be intersected tested against the scene by calling the intersect() function.This intersection() function will, in turn call  the intersection() function of the accelerator class which will soon be discussed. There are two over-loaded intersection function, one of which just return the boolean flag of either true/false and the other store the intersection information along with the boolean flags. The intersection information are used for shading, reflection, refraction. The latter version is slower than the former one.

Intersection interface
Image courtesy by:
Lund Graphics Group

• Intersection - It represents the ray/object intersection point. All the necessary information about the intersection is computed by the intersected object and stored in this class.

The main function do the following typical setup for the ray tracer[2]:

• Build a scene.
• Create materials, objects, lights.
• Create the image buffer represented by the Image class. It contains the size (width X height) of the image. Each pixel of the image is a Color object  with red, green, and blue components. There are functions to load and save the image in OpenEXR (.exr) and for getting and setting pixel values. This class is used as frame buffer in the ray tracer, storing the output color of each pixel, and also used in the LightProbe class for representing the environment map.
• Setup the perspective camera. The class Camera needs to know which Image object is used for the output image in order the extract the image dimensions. The camera can be set conveniently setup using the setLookAt() function, which takes a position, target and an up vector. The field of view parameter measures the FOV in degrees horizontally.
• Prepare the scene as mentioned above.
• Create the ray tracer object.
• Perform the ray tracing.
• Save the output image.

The following diagram will provide the reader a broader overview of this tiny renderer:

Skeleton Overview
Image courtesy by:
Lund Graphics Group

Whitted ray tracer launches up to three new rays at the intersection point between the ray and the intersection object; one for determining the shadow, one for perfect reflection, and one for perfect refraction. The shadow ray is always launched to determine if there is any objects located between the intersection point and the light source. Reflection and refraction rays are spawned based on the material properties of the intersected object.

The basic ray tracer embryo contains some spherical objects in the scene. It colors the pixel white if the ray hits anything, black otherwise.

Default output image from the
whitted ray tracer

As you can see from the above image that there is no light transport in the scene. It would be definitely more interesting if we would be able to apply the diffuse shading to the spheres. For now i only consider the direct illumination that originates from the point light source. The implementation will involve the calculation of the basic rendering equation as follows:

Rendering Equation

We can break the basic rendering equation as follows:

Breakdown of the rendering equation

The scene contain a number of point light sources.  We do the following calculation to get the contribution from the light source.

• The light vector is calculated from the intersection point to the point light and then normalize it and this is the incident light vector. 
• The incident angle - the dot product between the light vector and the normal at the intersection point is calculated.
• The BRDF(Bidirectional Reflectance Distribution Function) is calculated at the intersection point for the light vector which have been calculated.

I got the following output of the diffuse reflection:

Diffuse Reflection

So far shadows are not considered. If there is an object between the hit point and the light source, there is no direct illumination, and thus the direct lighting factor will be zero. By sending a shadow ray from the hit point to the light source and checking for intersections, i can determine if the hit point is in shadow or not. The following image illustrate the scenario:

The point p is not in shadow while the point q is not in shadow
Image Courtesy of Peter Shirley in
Fundamentals of Computer Graphics

Note that the intersection test only has to return a boolean, true or false answer, since we are not interested in any intersection information. To get the algorithm for shading, i add an if statement to determine if the point is in shadow or not. In the naive implementation, the shadow ray will check if the instance of intersection is between 0 and INFINITY. But, because of the numerical imprecision, this can result in an intersection with the surface the point in question (p) lies. Instead, the usual adjustment to address the problem is to add a small positive constant so that we can check the intersection between the positive constant and INFINITY. The following figure elaborates better , i believe:

By testing the interval starting at that positive constant, the numerical imprecision is
avoided causing the ray to hit the surface point under consideration
Image Courtesy of Peter Shirley in
Fundamentals of Computer Graphics

I generated the following image with shadow calculation:

Diffuse Reflection with Shadow ray

So far i have generated the diffuse reflection with shadow ray. Now the goal is to get more realistic looking image by adding reflection. Real world materials are of course neither perfectly diffuse nor perfectly specular, the combination of the two components can give fairly convincing polished materials.

Similar to the shadow rays in last addition, the reflectance can be spawned at the point of intersection. In this way, the ray originating at the eye can be traced recursively to account for alterations in the ray path caused by reflections.  Since we have reflection, the basic rendering equation is updated as follows:

The above equation contains a new parameter - specular reflectance , represented by r. For the time being it is enough to assume that specular reflectance affects all wavelengths equally ,and thus is a single coefficient between 0 and 1. If r = 0.0  it means that the surface is not reflective, and if r = 1.0, then the surface is a perfect mirror. Note that the resulting color is linearly interpolated using the specular reflectance. After adding this specular reflectance i get the following outpt:

Reflection with 5 recursive depth

Another important feature of the ray tracer is the ability to handle transparency and refractions. Many real materials are more or less transparent( glass, plastics, liquids, etc.). When lights enters a transparent material, it is usually bent or refracted. How much is determined by the index of refraction of the material. By the Snell's law we can compute the refraction vector T. Similar to the reflection term, i can add the refraction term to the transmittance model as follows:

Just like reflection, a refraction can be treated by recursively spawning a new ray at the hit point of a refractive surface where t > 0. Like before, i interpolate between the direct illumination, reflection and refraction components, so it should hold that r+t <= 1. Here goes the rendered image with reflection , refraction and shadow:

Reflection & Refraction with shadows

All of the images produced so far appear very jagged when examined at close up. This is because  i am only tracing a single ray through each pixel. To get a smoother result, it is necessary to use some kind of super-sampling.

To actually compute an estimate of the average color of the pixel, an algorithm is needed for picking "uniform" points on the pixel. There are several methods of obtaining samples within a pixel. Usually, such algorithms pick samples within the unit square. Two simple possibilities of generating sample over a unit square is show below:

Sampling strategies
Image courtesy of
Realistic Ray tracing
by
Peter Shirley

One of the problems of random sampling is that the given set of samples may be bunched together within the unit square if we are unlucky. It will give an inaccurate estimate of the pixel's color average color because we are using many samples within a small area of the pixel to estimate the whole pixel. It would be rather better to have all the samples more uniformly distributed  over the unit square. One method to avoid clumping is to choose our samples as the vertices of a uniform grid within the unit square. There is an additional benefit to this, since the computation is reduced as a result of the fact that the sample pattern only needs to be generated once for the entire image. This is because the same pattern is used for all pixels. Unfortunately, regular sampling suffers from a new flaw. Aliasing can occur as a result of the correlation of samples between pixels. There are many sampling techniques that attempt to have a good aspects of regular and random sampling. The following figure shows some of them[1].

Different Sampling Techniques
Image courtesy of
Realistic Ray tracing
By
Peter Shirley

I have used the multi-jittered sampling technique . Here goes the following image :

Multi-jittered sampling
with 100 primary rays per pixel

If you look at the image closely and compare it with the previous ones you will see the difference. At the same time i would like to stress that sampling for anti-aliasing is the weakest way of testing its strength. To really stress test them and expose their flaws, you need to use them for depth-of-field simulation, ambient occlusion, shading with area lights, particularly environment lights. Some of them will show up in my next post.


All of the images generated so far are way too perfect and far from being photo-realistic. The goal of photo-realism is addressed mainly by monte carlo path tracing techniques and their variations. I shall discuss the simplest one in my next post.



References

[1] Realistic Ray Tracing, Peter Shirley and R. Keith Morley
[2] Lund University Graphics Group
[3] Ray Tracing from Ground Up, Kevin Suffern
[4] Fundamentals of Computer Graphics, Peter Shirley