Simulating a Thin Lens Camera with Aperture Sampling

1. The Thin Lens Model in Code

To implement the thin lens model, our camera needs two new parameters, which directly correspond to the concepts from our last lesson:

1. Focus Distance (focus_dist): The distance from the camera's origin to the plane in the scene that is in perfect focus.
2. Defocus Angle (defocus_angle): An angle that controls the size of the aperture. A larger angle will mean a larger aperture, which in turn creates more blur (a shallower depth of field). A value of zero reverts us to a perfect pinhole camera.

We will follow the excellent implementation guide from the Ray Tracing in One Weekend series. The first step is to add these parameters to our camera class.

The defocus_disk_u and defocus_disk_v vectors represent the horizontal and vertical radii of our virtual aperture disk. Their lengths are calculated based on the defocus_angle and focus_dist. As you can see in the initialize() method from the reading:

auto defocus_radius = focus_dist * std::tan(degrees_to_radians(defocus_angle / 2));

This line uses basic trigonometry to determine the radius of the aperture disk in world-space units. A larger defocus_angle or a more distant focus_dist will result in a larger defocus_radius. This radius is then used to scale the camera's basis vectors u and v to create defocus_disk_u and defocus_disk_v.

2. How to Sample the Aperture Disk

With the aperture disk defined, the core of our task is to pick a random point on it for each ray we cast. This is where the Monte Carlo aspect of our ray tracer comes into play again, just like it did for antialiasing.

A crucial detail here is how we generate these random points. We need them to be uniformly distributed across the disk's area. A common first instinct might be to pick a random radius and a random angle. However, this simple approach incorrectly bunches samples toward the center of the disk.

There are two common and simple methods to achieve a uniform distribution:

1. Rejection Sampling: Generate a random point in a square that encloses the disk. If the point is outside the disk, reject it and try again. This is simple to code and statistically correct.
2. Mapping with Square Root: Generate a random angle $\theta$ from $0$ to $2\pi$ and a random value $r$ from $0$ to $1$. The radius of the sample point is $\sqrt{r}$. This corrects the clustering issue.

The Ray Tracing in One Weekend book uses rejection sampling, which is very clear and easy to implement.

3. Updating the Ray Generation

Now we can put all the pieces together. We'll modify our camera::get_ray() method to generate rays according to the thin lens model.

The core idea, which you saw visualized in the last lesson, is that while the ray's origin is randomized on the aperture disk, its direction is set to pass through the correct point on the focal plane.

The code to achieve this is remarkably concise. Here is the process inside get_ray():

1. Calculate the target point on the pixel grid as before, including the random jitter for antialiasing. This point lies on the focal plane.
2. Get a random point in the unit disk using random_in_unit_disk().
3. Scale that unit-disk point by our defocus_disk_u and defocus_disk_v vectors to find the offset on the actual aperture disk.
4. The new ray origin is center + offset.
5. The new ray direction is simply pixel_sample - ray_origin.

Now, let's look at the complete code.

4. Rendering Your First DoF Scene

With the camera class updated, you're ready to render! The final step is to set the new camera parameters in your main() function.

A good starting point for focus_dist is the distance to your subject. A simple way to do this is to set it to the length of the vector between your lookfrom and lookat points.

You should now be able to generate images with a clear depth of field effect. Objects at focus_dist will be sharp, while others will be blurred. The amount of blur will be controlled by defocus_angle.

Conclusion

Congratulations! You have now implemented one of the most visually important and pleasing effects in photorealistic rendering. By simulating a thin lens, you've moved beyond the limitations of a simple pinhole camera and can now control focus and depth of field just like a real photographer.

Key Takeaways:

• We added focus_dist and defocus_angle as parameters to our camera class to control depth of field.
• We learned how to generate uniformly random points on a disk, using rejection sampling as a simple and effective method.
• The core of the thin lens simulation is to originate rays from random points on an aperture disk, while directing them through a consistent point on the focal plane.
• The amount of blur (and resulting noise) is directly related to the defocus_angle and the number of samples per pixel.

Next Steps

Our camera model is now quite powerful. It supports a positionable viewpoint, variable field of view, antialiasing, and depth of field. The next logical step is to improve what our rays interact with. In the next module, we will begin our journey into Surface Materials and Light Scattering. You will learn to implement different material types, starting with diffuse (or matte) surfaces, and build a recursive ray tracing loop to simulate the way light bounces around a scene.