Introduction

Last week, we continued presenting the ray-tracing algorithm.
Recall in ray-tracing we cycle over each pixel on the screen, and determine a ray from the eye, through this pixel.
We then find the closest object hit by this ray and use it to compute a color to set the pixel.
In order to do this calculation, we needed to be able to compute intersections and the geometry our scene. So we showed how to compute ray-plane, ray-triangle, and ray-sphere intersections.
We then said that as intersection testing is the most computationally intensive part of ray-tracing, it is useful to split the geometry of the scene into larger scale structures which have simple to test bounding objects, do a test against the bounding object first to perhaps save computations on lots of the smaller elements of the geometry.
Today, we start from where we have just calculated the intersection of the ray with the object and consider how we might go about computing a color...

Secondary Rays

One advantage of ray tracing is that it gives an easy framework for calculating more sophisticated graphical phenomena.
For example, we can compute shadows due to a point light source.
To determine if a scene point is in shadow, one follows a shadow ray from the observed point toward the light to see if there is any occluding geometry.
Another calculation that can be done is mirror reflection (and similarly refraction).
One calculates the bounce direction using the incoming vector `vec w` as: `B(vec w) = 2(vec w cdot vec n)vec n - vec w`
where `vec n` is the normal at the intersection point.
We then see where the bounce ray hits the geometry of the scene. The color of the point hit by this ray is then calculated and used to determine the color of the original point on the mirror.
So the basic color of a pixel is then the color of the first object intersected together with a brightness determined by how well it is lit, together with the attenuated colors coming from reflections, refractions etc.
Reflections themselves might come from earlier reflected sources so the whole process is usual recursive to some cut off depth.

We are going to go into this process in more details as we start covering Chapter 21 material.
More realistic optical simulation requires the computation of integrals, and these integrals can often be approximated by summing up contributions along a set of samples. Computing the values for these samples often involves tracing rays through the scene.
We conclude the Chapter 20 material with an example of this.
Suppose we want to simulate a scene that is illuminated by a large light with finite area.
Such a light source will typically have soft shadow boundaries (unlike a point light source).
To approximate area light sources we send off a number of shadows rays toward the area light and determine how many of those rays hit the light source.

Which of the following statements is true?

Our plane intersection test presented last week involved the quadratic formula to determine `lambda`.
The triangle intersection test we had last week involved doing a plane intersection.
Our sphere intersection test of last week involved tessellating the sphere using triangles.

We now look in more detail at lighting models that may be used with ray tracing.
To get a high-quality light simulation: One needs to understand the proper units needed measure light and reflection. This in turn leas to equations that model how light behaves in a scene. Once we have these equations we can work towards algorithms which approximate solutions to these equations using ray-tracing.
In "geometric optics" we think of light as a field of photons flying through space.
In free space, each photon flies unmolested (photons don't collide with other photons) in a straight line, and each moves at the same speed.
When photons hit a surface, they scatter in various directions from that point.
We assume that the field we will eventually try to simulate is in equilibrium.

We next try to understand the units used for measuring light.
To do this we begin by describing some simple photon measurement and work towards a description of radiance.
We can think of light as a bunch of photons flying through space in various directions.
Suppose we has a sensor `(W,X)`, where `X` is a smooth imaginary reference surface and `W` is a wedge of directions.
In the sensor, we count the number of photons that come from any direction within the wedge `W` and pass through the surface `X`.
This sensor counts the number of photons it receives each second. Each photon carries energy measured in joules. The energy divided by time is a measurement called radiant flux and is measured in watts.
We denote a radiant flux measurement by the function `Phi(W, X)`.
We assume this is a continuous function of changes in our geometry such as translation, rotation, or change of scale.

Let's assume `X` is planar with normal `vec n`.
To approximate the light through a point `tilde x` on `X` we could divide the radiant flux by the area of `X`:
`E(W,X) = (Phi(W,X))/(|X|)`
As `X` gets smaller and smaller, `E(W,X)`, under continuity assumptions, we converge to a value that we call an incoming irradiance measurement. This is denoted `E_(vec n)(W, tilde x)`.
In the above, `vec n` is necessary in order to specify the orientation of the smaller and smaller sensors.
Sometimes the first argument for `E` is dropped from the notation and is inferred somehow from conventions and context. For example, it may be clear that `W` is the entire upper hemisphere above the point. Similarly, the normal parameter is often dropped from the notation and inferred from the context.

Suppose our finite sensor surface `X` is broken up into a bunch of smaller surfaces, `X_i`.
Then we can compute flux over the entire sensor as the sum:
`Phi(W, X) = sum_i Phi(W, X_i) = sum_i|X_i|E(W, X_i)`.
If we shrink the `X_i`, under reasonable continuity assumptions, we can compute the flux from the pointwise irradiance as
`Phi(W, X) = int_X dA E_(vec n(tilde x))(W, tilde x)`
The above integral is over the surface `X` where `dA` is an area measure over the positions `tilde x`.

We want to get rid of the dependency on `W` from our equation.
Thus, we want to divide out by `|W|`, the solid angle measure of `W`, that is, the area covered by the wedge on the unit sphere.
The units of such angles are called steradians. The wedge of all directions covers `4 pi` steradians.
We define:
`L_(vec n)(W, tilde x) = (E_(vec n)(W, tilde x))/(|W|)`
We can measure smaller and smaller wedges around a vector `vec w` pointing towards `tilde x`. In the limit this converges to a measurement `L_(vec n)(vec w, tilde x)`.
We can get rid of `vec n` by converting our measurement to a measurement of `L_(-vec w)(vec w, tilde x)`.
To do this, we have to account for the ratio between the areas of sensor surfaces as they are tilted. This can be calculated as
`L(vec w, tilde x) := L_(- vec w)(vec w, tilde x) = (L_(vec n)(vec w, tilde x))/(cos theta)`
where `theta` is the angle between `vec n` and `- vec w`.
We call this measurement the incoming radiance.

Given a spatially and angularly varying `L(vec w, tilde x)`, we can compute the radiant flux over a large sensor `(W, X)` as
`Phi(W, X) = int_X dA int_W dw L(vec w, tilde x) cos(theta)`
where `dw` is a differential measure of steradians.
Radiance measurements allow us to measure light at a point and direction without keeping track of size and orientation of the measurement device.
Radiance remains constant along a ray in free space.
That is,
`L(vec w, tilde x) = L(vec w, tilde x + vec w)`.
We will continue developing this model next day...