As an example, let’s estimate $\pi$. There are many ways to do this, with the Buffon Needle problem being a classic case study. We’ll do a variation inspired by that. Suppose you have a circle inscribed inside a square: ![Figure [circ-sq]: Estimating π with a circle inside a square](../images/fig.circ-sq.jpg)

Now, suppose you pick random points inside the square. The fraction of those random points that end up inside the circle should be proportional to the area of the circle. The exact fraction should in fact be the ratio of the circle area to the square area. Fraction: $$ \frac{\pi r^2}{(2r)^2} = \frac{\pi}{4} $$

Since the $r$ cancels out, we can pick whatever is computationally convenient. Let’s go with $r=1$, centered at the origin: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ #include "rtweekend.h" #include #include #include #include int main() { int N = 1000; int inside_circle = 0; for (int i = 0; i < N; i++) { auto x = random_double(-1,1); auto y = random_double(-1,1); if (x*x + y*y < 1) inside_circle++; } std::cout << std::fixed << std::setprecision(12); std::cout << "Estimate of Pi = " << 4*double(inside_circle) / N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [estpi-1]: [pi.cc] Estimating π]

If we change the program to run forever and just print out a running estimate: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ #include "rtweekend.h" #include #include #include #include int main() { int inside_circle = 0; int runs = 0; std::cout << std::fixed << std::setprecision(12); while (true) { runs++; auto x = random_double(-1,1); auto y = random_double(-1,1); if (x*x + y*y < 1) inside_circle++; if (runs % 100000 == 0) std::cout << "Estimate of Pi = " << 4*double(inside_circle) / runs << '\n'; } } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [estpi-2]: [pi.cc] Estimating π, v2]

We get very quickly near $\pi$, and then more slowly zero in on it. This is an example of the *Law of Diminishing Returns*, where each sample helps less than the last. This is the worst part of MC. We can mitigate this diminishing return by *stratifying* the samples (often called *jittering*), where instead of taking random samples, we take a grid and take one sample within each: ![Figure [jitter]: Sampling areas with jittered points](../images/fig.jitter.jpg)

This changes the sample generation, but we need to know how many samples we are taking in advance because we need to know the grid. Let’s take a hundred million and try it both ways: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ #include "rtweekend.h" #include #include int main() { int inside_circle = 0; int inside_circle_stratified = 0; int sqrt_N = 10000; for (int i = 0; i < sqrt_N; i++) { for (int j = 0; j < sqrt_N; j++) { auto x = random_double(-1,1); auto y = random_double(-1,1); if (x*x + y*y < 1) inside_circle++; x = 2*((i + random_double()) / sqrt_N) - 1; y = 2*((j + random_double()) / sqrt_N) - 1; if (x*x + y*y < 1) inside_circle_stratified++; } } auto N = static_cast(sqrt_N) * sqrt_N; std::cout << std::fixed << std::setprecision(12); std::cout << "Regular Estimate of Pi = " << 4*double(inside_circle) / (sqrt_N*sqrt_N) << '\n' << "Stratified Estimate of Pi = " << 4*double(inside_circle_stratified) / (sqrt_N*sqrt_N) << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [estpi-3]: [pi.cc] Estimating π, v3] On my computer, I get: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Regular Estimate of Pi = 3.14151480 Stratified Estimate of Pi = 3.14158948 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

In computer sciency notation, we might write this as: $$ I = \text{area}( x^2, 0, 2 ) $$ We could also write it as: $$ I = 2 \cdot \text{average}(x^2, 0, 2) $$

This suggests a MC approach: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ #include "rtweekend.h" #include #include #include #include int main() { int inside_circle = 0; int inside_circle_stratified = 0; int N = 1000000; double sum; for (int i = 0; i < N; i++) { auto x = random_double(0,2); sum += x*x; } std::cout << std::fixed << std::setprecision(12); std::cout << "I = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [integ-xsq-1]: [integrate_x_sq.cc] Integrating $x^2$]

First, what is a _density function_? It’s just a continuous form of a histogram. Here’s an example from the histogram Wikipedia page: ![Figure [histogram]: Histogram example](../images/fig.histogram.jpg)

If we added data for more trees, the histogram would get taller. If we divided the data into more bins, it would get shorter. A discrete density function differs from a histogram in that it normalizes the frequency y-axis to a fraction or percentage (just a fraction times 100). A continuous histogram, where we take the number of bins to infinity, can’t be a fraction because the height of all the bins would drop to zero. A density function is one where we take the bins and adjust them so they don’t get shorter as we add more bins. For the case of the tree histogram above we might try: $$ \text{bin-height} = \frac{(\text{Fraction of trees between height }H\text{ and }H’)}{(H-H’)} $$

That would work! We could interpret that as a statistical predictor of a tree’s height: $$ \text{Probability a random tree is between } H \text{ and } H’ = \text{bin-height}\cdot(H-H’)$$

The height is just $p(2)$. What should that be? We could reasonably make it anything by convention, and we should pick something that is convenient. Just as with histograms we can sum up (integrate) the region to figure out the probability that $r$ is in some interval $(x_0,x_1)$: $$ \text{Probability } x_0 < r < x_1 = C \cdot \text{area}(p(r), x_0, x_1) $$

where $C$ is a scaling constant. We may as well make $C = 1$ for cleanliness, and that is exactly what is done in probability. And we know the probability $r$ has the value 1 somewhere, so for this case $$ \text{area}(p(r), 0, 2) = 1 $$

Since $p(r)$ is proportional to $r$, _i.e._, $p = C' \cdot r$ for some other constant $C'$ $$ area(C'r, 0, 2) = \int_{0}^{2} C' r dr = \frac{C'r^2}{2} \biggr|_{r=2}^{r=0} = \frac{C' \cdot 2^2}{2} - \frac{C' \cdot 0^2}{2} = 2C' $$ So $p(r) = r/2$.

Given a random number from `d = random_double()` that is uniform and between 0 and 1, we should be able to find some function $f(d)$ that gives us what we want. Suppose $e = f(d) = d^2$. This is no longer a uniform PDF. The PDF of $e$ will be bigger near 0 than it is near 1 (squaring a number between 0 and 1 makes it smaller). To convert this general observation to a function, we need the cumulative probability distribution function $P(x)$: $$ P(x) = \text{area}(p, -\infty, x) $$

Note that for $x$ where we didn’t define $p(x)$, $p(x) = 0$, _i.e._, the probability of an $x$ there is zero. For our example PDF $p(r) = r/2$, the $P(x)$ is: $$ P(x) = 0 : x < 0 $$ $$ P(x) = \frac{x^2}{4} : 0 < x < 2 $$ $$ P(x) = 1 : x > 2 $$

One question is, what’s up with $x$ versus $r$? They are dummy variables -- analogous to the function arguments in a program. If we evaluate $P$ at $x = 1.0$, we get: $$ P(1.0) = \frac{1}{4} $$

This says _the probability that a random variable with our PDF is less than one is 25%_. This gives rise to a clever observation that underlies many methods to generate non-uniform random numbers. We want a function `f()` that when we call it as `f(random_double())` we get a return value with a PDF $\frac{x^2}{4}$. We don’t know what that is, but we do know that 25% of what it returns should be less than 1.0, and 75% should be above 1.0. If $f()$ is increasing, then we would expect $f(0.25) = 1.0$. This can be generalized to figure out $f()$ for every possible input: $$ f(P(x)) = x $$

That means $f$ just undoes whatever $P$ does. So, $$ f(x) = P^{-1}(x) $$

The -1 means “inverse function”. Ugly notation, but standard. For our purposes what this means is, if we have PDF $p()$ and cumulative distribution function $P()$, then if we use this "inverse function" with a random number we’ll get what we want: $$ e = P^{-1} (\text{random_double}()) $$

For our PDF $p(x) = x/2$, and corresponding $P(x)$, we need to compute the inverse of $P$. If we have $$ y = \frac{x^2}{4} $$ we get the inverse by solving for $x$ in terms of $y$: $$ x = \sqrt{4y} $$ Thus our random number with density $p$ is found with: $$ e = \sqrt{4\cdot\text{random_double}()} $$

We can now sample our old integral $$ I = \int_{0}^{2} x^2 $$

We need to account for the non-uniformity of the PDF of $x$. Where we sample too much we should down-weight. The PDF is a perfect measure of how much or little sampling is being done. So the weighting function should be proportional to $1/pdf$. In fact it is exactly $1/pdf$: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight inline double pdf(double x) { return 0.5*x; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ int main() { int inside_circle = 0; int inside_circle_stratified = 0; int N = 1000000; auto sum = 0.0; for (int i = 0; i < N; i++) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight auto x = sqrt(random_double(0,4)); sum += x*x / pdf(x); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ } std::cout << std::fixed << std::setprecision(12); std::cout << "I = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [integ-xsq-2]: [integrate_x_sq.cc] Integrating $x^2$ with PDF]

If we take that same code with uniform samples so the PDF = $1/2$ over the range [0,2] we can use the machinery to get `x = random_double(0,2)` and the code is: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight inline double pdf(double x) { return 0.5; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ int main() { int inside_circle = 0; int inside_circle_stratified = 0; int N = 1000000; auto sum = 0.0; for (int i = 0; i < N; i++) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight auto x = random_double(0,2); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ sum += x*x / pdf(x); } std::cout << std::fixed << std::setprecision(12); std::cout << "I = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [integ-xsq-3]: [integrate_x_sq.cc] Integrating $x^2$, v3]

Note that we don’t need that 2 in the `2*sum/N` anymore -- that is handled by the PDF, which is 2 when you divide by it. You’ll note that importance sampling helps a little, but not a ton. We could make the PDF follow the integrand exactly: $$ p(x) = \frac{3}{8}x^2 $$ And we get the corresponding $$ P(x) = \frac{x^3}{8} $$ and $$ P^{-1}(x) = 8x^\frac{1}{3} $$

This perfect importance sampling is only possible when we already know the answer (we got $P$ by integrating $p$ analytically), but it’s a good exercise to make sure our code works. For just 1 sample we get: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight inline double pdf(double x) { return 3*x*x/8; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ int main() { int inside_circle = 0; int inside_circle_stratified = 0; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight int N = 1; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ auto sum = 0.0; for (int i = 0; i < N; i++) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight auto x = pow(random_double(0,8), 1./3.); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ sum += x*x / pdf(x); } std::cout << std::fixed << std::setprecision(12); std::cout << "I = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [integ-xsq-4]: [integrate_x_sq.cc] Integrating $x^2$, final version]

Let’s review now because that was most of the concepts that underlie MC ray tracers. 1. You have an integral of $f(x)$ over some domain $[a,b]$ 2. You pick a PDF $p$ that is non-zero over $[a,b]$ 3. You average a whole ton of $\frac{f(r)}{p(r)}$ where $r$ is a random number with PDF $p$. Any choice of PDF $p$ will always converge to the right answer, but the closer that $p$ approximates $f$, the faster that it will converge.

By MC integration, we should just be able to sample $\cos^2(\theta) / p(\text{direction})$. But what is direction in that context? We could make it based on polar coordinates, so $p$ would be in terms of $(\theta, \phi)$. However you do it, remember that a PDF has to integrate to 1 and represent the relative probability of that direction being sampled. We have a method from the last books to take uniform random samples in or on a unit sphere: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 random_in_unit_sphere() { while (true) { auto p = vec3::random(-1,1); if (p.length_squared() >= 1) continue; return p; } } vec3 random_unit_vector() { auto a = random_double(0, 2*pi); auto z = random_double(-1, 1); auto r = sqrt(1 - z*z); return vec3(r*cos(a), r*sin(a), z); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [random-unit-vector]: [vec3.h] Random vector of unit length]

Now what is the PDF of these uniform points? As a density on the unit sphere, it is $1/\text{area}$ of the sphere or $1/(4\pi)$. If the integrand is $\cos^2(\theta)$ and $\theta$ is the angle with the z axis: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ inline double pdf(const vec3& p) { return 1 / (4*pi); } int main() { int N = 1000000; auto sum = 0.0; for (int i = 0; i < N; i++) { vec3 d = random_unit_vector(); auto cosine_squared = d.z()*d.z(); sum += cosine_squared / pdf(d); } std::cout << std::fixed << std::setprecision(12); std::cout << "I = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [main-sphereimp]: [sphere_importance.cc] Generating importance-sampled points on the unit sphere]

The color of a surface in terms of these quantities is: $$ Color = \int A \cdot s(direction) \cdot \text{color}(direction) $$

If we apply the MC basic formula we get the following statistical estimate: $$ Color = \frac{A \cdot s(direction) \cdot \text{color}(direction)}{p(direction)} $$ where $p(direction)$ is the PDF of whatever direction we randomly generate.

To see that, remember that in spherical coordinates: $$ dA = \sin(\theta) d\theta d\phi $$ So: $$ Area = \int_{0}^{2 \pi} \int_{0}^{\pi / 2} cos(\theta) sin(\theta) d\theta d\phi = 2 \pi \frac{1}{2} = \pi $$

So for a Lambertian surface the scattering PDF is: $$ s(direction) = \frac{\cos(\theta)}{\pi} $$

If we sample using a PDF that equals the scattering PDF: $$ p(direction) = s(direction) = \frac{\cos(\theta)}{\pi} $$ The numerator and denominator cancel out and we get: $$ Color = A \cdot color(direction) $$ This is exactly what we had in our original `ray_color()` function! But we need to generalize now so we can send extra rays in important directions such as toward the lights. The treatment above is slightly non-standard because I want the same math to work for surfaces and volumes. To do otherwise will make some ugly code.

If you read the literature, you’ll see reflection described by the bidirectional reflectance distribution function (BRDF). It relates pretty simply to our terms: $$ BRDF = \frac{A \cdot s(direction)}{\cos(\theta)} $$ So for a Lambertian surface for example, $BRDF = A / \pi$. Translation between our terms and BRDF is easy. For participation media (volumes), our albedo is usually called _scattering albedo_, and our scattering PDF is usually called _phase function_.

Our goal over the next two chapters is to instrument our program to send a bunch of extra rays toward light sources so that our picture is less noisy. Let’s assume we can send a bunch of rays toward the light source using a PDF $pLight(direction)$. Let’s also assume we have a PDF related to $s$, and let’s call that $pSurface(direction)$. A great thing about PDFs is that you can just use linear mixtures of them to form mixture densities that are also PDFs. For example, the simplest would be: $$ p(direction) = \frac{1}{2}\cdotp Light(direction) + \frac{1}{2}\cdot pSurface(direction) $$

Let’s do simple refactoring and temporarily remove all materials that aren’t Lambertian. We can use our Cornell Box scene again, and let’s generate the camera in the function that generates the model: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ hittable_list cornell_box(camera& cam, double aspect) { hittable_list world; auto red = make_shared(make_shared(vec3(0.65, 0.05, 0.05))); auto white = make_shared(make_shared(vec3(0.73, 0.73, 0.73))); auto green = make_shared(make_shared(vec3(0.12, 0.45, 0.15))); auto light = make_shared(make_shared(vec3(15, 15, 15))); world.add(make_shared(make_shared(0, 555, 0, 555, 555, green))); world.add(make_shared(0, 555, 0, 555, 0, red)); world.add(make_shared(make_shared(213, 343, 227, 332, 554, light))); world.add(make_shared(make_shared(0, 555, 0, 555, 555, white))); world.add(make_shared(0, 555, 0, 555, 0, white)); world.add(make_shared(make_shared(0, 555, 0, 555, 555, white))); shared_ptr box1 = make_shared(vec3(0,0,0), vec3(165,330,165), white); box1 = make_shared(box1, 15); box1 = make_shared(box1, vec3(265,0,295)); world.add(box1); shared_ptr box2 = make_shared(vec3(0,0,0), vec3(165,165,165), white); box2 = make_shared(box2, -18); box2 = make_shared(box2, vec3(130,0,65); world.add(box2); vec3 lookfrom(278, 278, -800); vec3 lookat(278, 278, 0); vec3 vup(0, 1, 0); auto dist_to_focus = 10.0; auto aperture = 0.0; auto vfov = 40.0; auto t0 = 0.0; auto t1 = 1.0; cam = camera(lookfrom, lookat, vup, vfov, aspect, aperture, dist_to_focus, t0, t1); return world; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [cornell-box]: [main.cc] Cornell box, refactored]

At 500×500 my code produces this image in 10min on 1 core of my Macbook:  Reducing that noise is our goal. We’ll do that by constructing a PDF that sends more rays to the light.

We modify the base-class `material` to enable this importance sampling: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class material { public: virtual bool scatter( const ray& r_in, const hit_record& rec, vec3& albedo, ray& scattered, double& pdf ) const { return false; } virtual double scattering_pdf( const ray& r_in, const hit_record& rec, const ray& scattered ) const { return 0; } virtual vec3 emitted(double u, double v, const vec3& p) const { return vec3(0,0,0); } }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-material]: [material.h] The material class, adding importance sampling]

And _Lambertian_ material becomes: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class lambertian : public material { public: lambertian(shared_ptr a) : albedo(a) {} bool scatter( const ray& r_in, const hit_record& rec, vec3& alb, ray& scattered, double& pdf ) const { vec3 target = rec.p + rec.normal + random_unit_vector(); scattered = ray(rec.p, unit_vector(target-rec.p), r_in.time()); alb = albedo->value(rec.u, rec.v, rec.p); pdf = dot(rec.normal, scattered.direction()) / pi; return true; } double scattering_pdf( const ray& r_in, const hit_record& rec, const ray& scattered ) const { auto cosine = dot(rec.normal, unit_vector(scattered.direction())); return cosine < 0 ? 0 : cosine/pi; } public: shared_ptr albedo; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-lambertian-impsample]: [material.h] Lambertian material, modified for importance sampling]

And the color function gets a minor modification: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color(const ray& r, const vec3& background, const hittable& world, int depth) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ray scattered; vec3 attenuation; vec3 emitted = rec.mat_ptr->emitted(rec.u, rec.v, rec.p); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight double pdf; vec3 albedo; if (!rec.mat_ptr->scatter(r, rec, albedo, scattered, pdf)) return emitted; return emitted + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, depth-1) / pdf; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-impsample]: [main.cc] The ray_color function, modified for importance sampling]

Now, just for the experience, try a different sampling strategy. As in the first book, Let’s choose randomly from the hemisphere above the surface. This would be $p(direction) = \frac{1}{2\pi}$. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ bool scatter( const ray& r_in, const hit_record& rec, vec3& alb, ray& scattered, double& pdf ) const { vec3 direction = random_in_hemisphere(rec.normal); scattered = ray(rec.p, unit_vector(direction), r_in.time()); alb = albedo->value(rec.u, rec.v, rec.p); pdf = 0.5 / pi; return true; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [scatter-mod]: [material.h] Modified scatter function]

And again I _should_ get the same picture except with different variance, but I don’t! 

Given a directional PDF, $p(direction) = f(\theta)$ on the sphere, the 1D PDFs on $\theta$ and $\phi$ are: $$ a(\phi) = \frac{1}{2\pi} $$ (uniform) $$ b(\theta) = 2\pi f(\theta)\sin(\theta) $$

For uniform random numbers $r_1$ and $r_2$, the material presented in the One Dimensional MC Integration chapter leads to: $$ r_1 = \int_{0}^{\phi} \frac{1}{2\pi} dt = \frac{\phi}{2\pi} $$ Solving for $\phi$ we get: $$ \phi = 2 \pi \cdot r_1 $$ For $\theta$ we have: $$ r_2 = \int_{0}^{\theta} 2 \pi f(t) \sin(t) dt $$

Here, $t$ is a dummy variable. Let’s try some different functions for $f()$. Let’s first try a uniform density on the sphere. The area of the unit sphere is $4\pi$, so a uniform $p(direction) = \frac{1}{4\pi}$ on the unit sphere. $$ r_2 = \int_{0}^{\theta} 2 \pi \frac{1}{4\pi} \sin(t) dt $$ $$ = \int_{0}^{\theta} \frac{1}{2} \sin(t) dt $$ $$ = \frac{-\cos(\theta)}{2} - \frac{-\cos(0)}{2} $$ $$ = \frac{1 - \cos(\theta)}{2} $$ Solving for $\cos(\theta)$ gives: $$ \cos(\theta) = 1 - 2 r_2 $$ We don’t solve for theta because we probably only need to know $\cos(\theta)$ anyway and don’t want needless $\arccos()$ calls running around.

To generate a unit vector direction toward $(\theta,\phi)$ we convert to Cartesian coordinates: $$ x = \cos(\phi) \cdot \sin(\theta) $$ $$ y = \sin(\phi) \cdot \sin(\theta) $$ $$ z = \cos(\theta) $$ And using the identity that $\cos^2 + \sin^2 = 1$, we get the following in terms of random $(r_1,r_2)$: $$ x = \cos(2\pi \cdot r_1)\sqrt{1 - (1-2 r_2)^2} $$ $$ y = \sin(2\pi \cdot r_1)\sqrt{1 - (1-2 r_2)^2} $$ $$ z = 1 - 2 r_2 $$ Simplifying a little, $(1 - 2 r_2)^2 = 1 - 4r_2 + 4r_2^2$, so: $$ x = \cos(2 \pi r_1) \cdot 2 \sqrt{r_2(1 - r_2)} $$ $$ y = \sin(2 \pi r_1) \cdot 2 \sqrt{r_2(1 - r_2)} $$ $$ z = 1 - 2 r_2 $$

We can output some of these: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ int main() { for (int i = 0; i < 200; i++) { auto r1 = random_double(); auto r2 = random_double(); auto x = cos(2*pi*r1)*2*sqrt(r2*(1-r2)); auto y = sin(2*pi*r1)*2*sqrt(r2*(1-r2)); auto z = 1 - 2*r2; std::cout << x << " " << y << " " << z << '\n'; } } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [rand-unit-sphere-plot]: [sphere_plot.cc] Random points on the unit sphere]

And plot them for free on plot.ly (a great site with 3D scatterplot support): ![Figure [pt-uni-sphere]: Random points on the unit sphere](../images/fig.pt-uni-sphere.jpg)

Now let’s derive uniform on the hemisphere. The density being uniform on the hemisphere means $p(direction) = \frac{1}{2\pi}$ and just changing the constant in the theta equations yields: $$ \cos(\theta) = 1 - r_2 $$

It is comforting that $\cos(\theta)$ will vary from 1 to 0, and thus theta will vary from 0 to $\pi/2$. Rather than plot it, let’s do a 2D integral with a known solution. Let’s integrate cosine cubed over the hemisphere (just picking something arbitrary with a known solution). First let’s do it by hand: $$ \int \cos^3(\theta) dA $$ $$ = \int_{0}^{2 \pi} \int_{0}^{\pi /2} \cos^3(\theta) \sin(\theta) d\theta d\phi $$ $$ = 2 \pi \int_{0}^{\pi/2} \cos^3(\theta) \sin(\theta) = \frac{\pi}{2} $$

Now for integration with importance sampling. $p(direction) = \frac{1}{2\pi}$, so we average $f/p$ which is $\cos^3(\theta) / (1/(2 \pi))$, and we can test this: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ int main() { int N = 1000000; auto sum = 0.0; for (int i = 0; i < N; i++) { auto r1 = random_double(); auto r2 = random_double(); auto x = cos(2*pi*r1)*2*sqrt(r2*(1-r2)); auto y = sin(2*pi*r1)*2*sqrt(r2*(1-r2)); auto z = 1 - r2; sum += z*z*z / (1.0/(2.0*pi)); } std::cout << std::fixed << std::setprecision(12); std::cout << "Pi/2 = " << pi/2 << '\n'; std::cout << "Estimate = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [cos-cubed]: [cos_cubed.cc] Integration using $cos^3(x)$]

Now let’s generate directions with $p(directions) = \cos(\theta) / \pi$. $$ r_2 = \int_{0}^{\theta} 2 \pi \frac{\cos(t)}{\pi} \sin(t) = 1 - \cos^2(\theta) $$ So, $$ \cos(\theta) = \sqrt{1 - r_2} $$ We can save a little algebra on specific cases by noting $$ z = \cos(\theta) = \sqrt{1 - r_2} $$ $$ x = \cos(\phi) \sin(\theta) = \cos(2 \pi r_1) \sqrt{1 - z^2} = \cos(2 \pi r_1) \sqrt{r_2} $$ $$ y = \sin(\phi) \sin(\theta) = \sin(2 \pi r_1) \sqrt{1 - z^2} = \sin(2 \pi r_1) \sqrt{r_2} $$

Let’s also start generating them as random vectors: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ #include "rtweekend.h" #include #include inline vec3 random_cosine_direction() { auto r1 = random_double(); auto r2 = random_double(); auto z = sqrt(1-r2); auto phi = 2*pi*r1; auto x = cos(phi)*sqrt(r2); auto y = sin(phi)*sqrt(r2); return vec3(x, y, z); } int main() { int N = 1000000; auto sum = 0.0; for (int i = 0; i < N; i++) { vec3 v = random_cosine_direction(); sum += v.z()*v.z()*v.z() / (v.z()/pi); } std::cout << std::fixed << std::setprecision(12); std::cout << "Pi/2 = " << pi/2 << '\n'; std::cout << "Estimate = " << sum/N << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [cos-density]: [cos_density.cc] Integration with cosine density function]

Suppose we have an origin $\mathbf{o}$ and cartesian unit vectors $\vec{\mathbf{x}}$, $\vec{\mathbf{y}}$, and $\vec{\mathbf{z}}$. When we say a location is (3, -2, 7), we really are saying: $$ \text{Location is } \mathbf{o} + 3\vec{\mathbf{x}} - 2\vec{\mathbf{y}} + 7\vec{\mathbf{z}} $$

If we want to measure coordinates in another coordinate system with origin $\mathbf{o}'$ and basis vectors $\vec{\mathbf{u}}$, $\vec{\mathbf{v}}$, and $\vec{\mathbf{w}}$, we can just find the numbers $(u, v, w)$ such that: $$ \text{Location is } \mathbf{o}' + u\vec{\mathbf{u}} + v\vec{\mathbf{v}} + w\vec{\mathbf{w}} $$

Some models will come with one or more cotangent vectors. If our model has only one cotangent vector, then the process of making an ONB is a nontrivial one. Suppose we have any vector $\vec{\mathbf{a}}$ that is of nonzero length and not parallel to $\vec{\mathbf{n}}$. We can get vectors $\vec{\mathbf{s}}$ and $\vec{\mathbf{t}}$ perpendicular to $\vec{\mathbf{n}}$ by using the property of the cross product that $\vec{\mathbf{c}} \times \vec{\mathbf{d}}$ is perpendicular to both $\vec{\mathbf{c}}$ and $\vec{\mathbf{d}}$: $$ \vec{\mathbf{t}} = \text{unit_vector}(\vec{\mathbf{a}} \times \vec{\mathbf{n}}) $$ $$ \vec{\mathbf{s}} = \vec{\mathbf{t}} \times \vec{\mathbf{n}} $$

This is all well and good, but the catch is that we may not be given an $\vec{\mathbf{a}}$ when we load a model, and we don't have an $\vec{\mathbf{a}}$ with our existing program. If we went ahead and picked an arbitrary $\vec{\mathbf{a}}$ to use as our initial vector we may get an $\vec{\mathbf{a}}$ that is parallel to $\vec{\mathbf{n}}$. A common method is to use an if-statement to determine whether $\vec{\mathbf{n}}$ is a particular axis, and if not, use that axis. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if absolute(n.x > 0.9) a ← (0, 1, 0) else a ← (1, 0, 0) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Once we have an ONB of $\vec{\mathbf{s}}$, $\vec{\mathbf{t}}$, and $\vec{\mathbf{n}}$ and we have a $random(x,y,z)$ relative to the Z-axis we can get the vector relative to $\vec{n}$ as: $$ \text{Random vector} = x \vec{\mathbf{s}} + y \vec{\mathbf{t}} + z \vec{\mathbf{n}} $$

You may notice we used similar math to get rays from a camera. That could be viewed as a change to the camera’s natural coordinate system. Should we make a class for ONBs or are utility functions enough? I’m not sure, but let’s make a class because it won't really be more complicated than utility functions: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class onb { public: onb() {} inline vec3 operator[](int i) const { return axis[i]; } vec3 u() const { return axis[0]; } vec3 v() const { return axis[1]; } vec3 w() const { return axis[2]; } vec3 local(double a, double b, double c) const { return a*u() + b*v() + c*w(); } vec3 local(const vec3& a) const { return a.x()*u() + a.y()*v() + a.z()*w(); } void build_from_w(const vec3&); public: vec3 axis[3]; }; void onb::build_from_w(const vec3& n) { axis[2] = unit_vector(n); vec3 a = (fabs(w().x()) > 0.9) ? vec3(0,1,0) : vec3(1,0,0); axis[1] = unit_vector(cross(w(), a)); axis[0] = cross(w(), v()); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-onb]: [onb.h] Ortho-normal basis class]

We can rewrite our Lambertian material using this to get: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ bool scatter( const ray& r_in, const hit_record& rec, vec3& alb, ray& scattered, double& pdf ) const { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight onb uvw; uvw.build_from_w(rec.normal); vec3 direction = uvw.local(random_cosine_direction()); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ scattered = ray(rec.p, unit_vector(direction), r_in.time()); alb = albedo->value(rec.u, rec.v, rec.p); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight pdf = dot(uvw.w(), scattered.direction()) / pi; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ return true; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [scatter-onb]: [material.h] Scatter function, with ortho-normal basis]

Which produces:  Is that right? We still don’t know for sure. Tracking down bugs is hard in the absence of reliable reference solutions. Let’s table that for now and move on to get rid of some of that noise.

It’s really easy to pick a random direction toward the light; just pick a random point on the light and send a ray in that direction. We also need to know the PDF, $p(direction)$. What is that? For a light of area $A$, if we sample uniformly on that light, the PDF on the surface of the light is $\frac{1}{A}$. But what is it on the area of the unit sphere that defines directions? Fortunately, there is a simple correspondence, as outlined in the diagram: ![Figure [light-pdf]: Projection of light shape onto PDF](../images/fig.light-pdf.jpg)

If we look at a small area $dA$ on the light, the probability of sampling it is $p_q(q) \cdot dA$. On the sphere, the probability of sampling the small area $dw$ on the sphere is $p(direction) \cdot dw$. There is a geometric relationship between $dw$ and $dA$: $$ dw = \frac{dA \cdot \cos(alpha)}{distance^2(p,q)} $$ Since the probability of sampling dw and dA must be the same, we have $$ p(direction) \cdot \frac{dA \cdot \cos(alpha)}{distance^2(p,q)} = p_q(q) \cdot dA = \frac{dA}{A} $$ So $$ p(direction) = \frac{distance^2(p,q)}{\cos(alpha) \cdot A} $$

If we hack our `ray_color()` function to sample the light in a very hard-coded fashion just to check that math and get the concept, we can add it (see the highlighted region): ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color(const ray& r, const vec3& background, const hittable& world, int depth) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ray scattered; vec3 attenuation; vec3 emitted = rec.mat_ptr->emitted(rec.u, rec.v, rec.p); double pdf; vec3 albedo; if (!rec.mat_ptr->scatter(r, rec, albedo, scattered, pdf)) return emitted; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight vec3 on_light = vec3(random_double(213,343), 554, random_double(227,332)); vec3 to_light = on_light - rec.p; auto distance_squared = to_light.length_squared(); to_light.make_unit_vector(); if (dot(to_light, rec.normal) < 0) return emitted; double light_area = (343-213)*(332-227); auto light_cosine = fabs(to_light.y()); if (light_cosine < 0.000001) return emitted; pdf = distance_squared / (light_cosine * light_area); scattered = ray(rec.p, to_light, r.time()); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ return emitted + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, depth-1) / pdf; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-lights]: [main.cc] Ray color with light sampling]

With 10 samples per pixel this yields: 

This is about what we would expect from something that samples only the light sources, so this appears to work. The noisy pops around the light on the ceiling are because the light is two-sided and there is a small space between light and ceiling. We probably want to have the light just emit down. We can do that by letting the emitted member function of hittable take extra information: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ virtual vec3 emitted(const ray& r_in, const hit_record& rec, double u, double v, const vec3& p) const { if (rec.front_face) return emit->value(u, v, p); else return vec3(0,0,0); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [emitted-directional]: [material.h] Material emission, directional]

We also need to flip the light so its normals point in the -y direction and we get: 

We have used a PDF related to $\cos(\theta)$, and a PDF related to sampling the light. We would like a PDF that combines these. A common tool in probability is to mix the densities to form a mixture density. Any weighted average of PDFs is a PDF. For example, we could just average the two densities: $$ pdf\_mixture(direction) = \frac{1}{2} pdf\_reflection(direction) + \frac{1}{2}pdf\_light(direction) $$

How would we instrument our code to do that? There is a very important detail that makes this not quite as easy as one might expect. Choosing the random direction is simple: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if (random_double() < 0.5) Pick direction according to pdf_reflection else Pick direction according to pdf_light ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If we step back a bit, we see that there are two functions a PDF needs to support: 1. What is your value at this location? 2. Return a random number that is distributed appropriately.

The details of how this is done under the hood varies for the $pdf\_reflection$ and the $pdf\_light$ and the mixture density of the two of them, but that is exactly what class hierarchies were invented for! It’s never obvious what goes in an abstract class, so my approach is to be greedy and hope a minimal interface works, and for the PDF this implies: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class pdf { public: virtual ~pdf() {} virtual double value(const vec3& direction) const = 0; virtual vec3 generate() const = 0; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-pdf]: [pdf.h] The `pdf` class]

First, let’s try a cosine density: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ inline vec3 random_cosine_direction() { auto r1 = random_double(); auto r2 = random_double(); auto z = sqrt(1-r2); auto phi = 2*pi*r1; auto x = cos(phi)*sqrt(r2); auto y = sin(phi)*sqrt(r2); return vec3(x, y, z); } class cosine_pdf : public pdf { public: cosine_pdf(const vec3& w) { uvw.build_from_w(w); } virtual double value(const vec3& direction) const { auto cosine = dot(unit_vector(direction), uvw.w()); return (cosine <= 0) ? 0 : cosine/pi; } virtual vec3 generate() const { return uvw.local(random_cosine_direction()); } public: onb uvw; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-cos-pdf]: [pdf.h] The cosine_pdf class]

We can try this in the `ray_color()` function, with the main changes highlighted. We also need to change variable `pdf` to some other variable name to avoid a name conflict with the new `pdf` class. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color(const ray& r, const vec3& background, const hittable& world, int depth) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ray scattered; vec3 attenuation; vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p); double pdf_val; vec3 albedo; if (!rec.mat_ptr->scatter(r, rec, albedo, scattered, pdf_val)) return emitted; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight cosine_pdf p(rec.normal); scattered = ray(rec.p, p.generate(), r.time()); pdf_val = p.value(scattered.direction()); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ return emitted + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, depth-1) / pdf_val; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-cos-pdf]: [main.cc] The ray_color function, using cosine pdf]

This yields an apparently matching result so all we’ve done so far is refactor where `pdf` is computed: 

Now we can try sampling directions toward a `hittable` like the light. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class hittable_pdf : public pdf { public: hittable_pdf(shared_ptr p, const vec3& origin) : ptr(p), o(origin) {} virtual double value(const vec3& direction) const { return ptr->pdf_value(o, direction); } virtual vec3 generate() const { return ptr->random(o); } public: vec3 o; shared_ptr ptr; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-hittable-pdf]: [pdf.h] The hittable_pdf class]

This assumes two as-yet not implemented functions in the `hittable` class. To avoid having to add instrumentation to all `hittable` subclasses, we’ll add two dummy functions to the `hittable` class: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class hittable { public: virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const = 0; virtual bool bounding_box(double t0, double t1, aabb& output_box) const = 0; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight virtual double pdf_value(const vec3& o, const vec3& v) const { return 0.0; } virtual vec3 random(const vec3& o) const { return vec3(1, 0, 0); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [hittable-plus2]: [hittable.h] The hittable class, with two new methods]

And we change `xz_rect` to implement those functions: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class xz_rect: public hittable { public: xz_rect() {} xz_rect( double _x0, double _x1, double _z0, double _z1, double _k, shared_ptr mat) : x0(_x0), x1(_x1), z0(_z0), z1(_z1), k(_k), mp(mat) {}; virtual bool hit(const ray& r, double t0, double t1, hit_record& rec) const; virtual bool bounding_box(double t0, double t1, aabb& output_box) const { output_box = aabb(vec3(x0,k-0.0001,z0), vec3(x1, k+0.0001, z1)); return true; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight virtual double pdf_value(const vec3& origin, const vec3& v) const { hit_record rec; if (!this->hit(ray(origin, v), 0.001, infinity, rec)) return 0; auto area = (x1-x0)*(z1-z0); auto distance_squared = rec.t * rec.t * v.length_squared(); auto cosine = fabs(dot(v, rec.normal) / v.length()); return distance_squared / (cosine * area); } virtual vec3 random(const vec3& origin) const { vec3 random_point = vec3(random_double(x0,x1), k, random_double(z0,z1)); return random_point - origin; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ public: shared_ptr mp; double x0, x1, z0, z1, k; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [xz-rect-pdf]: [aarect.h] XZ rect with pdf]

And then change `ray_color()`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color(const ray& r, const vec3& background, const hittable& world, int depth) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ray scattered; vec3 attenuation; vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p); double pdf_val; vec3 albedo; if (!rec.mat_ptr->scatter(r, rec, albedo, scattered, pdf_val)) return emitted; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight shared_ptr light_shape = make_shared(213, 343, 227, 332, 554, 0); hittable_pdf p(light_shape, rec.p); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ scattered = ray(rec.p, p.generate(), r.time()); pdf_val = p.value(scattered.direction()); return emitted + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, depth-1) / pdf_val; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-hittable-pdf]: [main.cc] ray_color function with hittable PDF]

At 10 samples per pixel we get: 

Now we would like to do a mixture density of the cosine and light sampling. The mixture density class is straightforward: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class mixture_pdf : public pdf { public: mixture_pdf(shared_ptr p0, shared_ptr p1) { p[0] = p0; p[1] = p1; } virtual double value(const vec3& direction) const { return 0.5 * p[0]->value(direction) + 0.5 *p[1]->value(direction); } virtual vec3 generate() const { if (random_double() < 0.5) return p[0]->generate(); else return p[1]->generate(); } public: shared_ptr p[2]; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [class-mixturep-df]: [pdf.h] The `mixture_pdf` class]

And plugging it into `ray_color()`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight vec3 ray_color( const ray& r, const vec3& background, const hittable& world, shared_ptr lights, int depth ) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ray scattered; vec3 attenuation; vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p); double pdf_val; vec3 albedo; if (!rec.mat_ptr->scatter(r, rec, albedo, scattered, pdf_val)) return emitted; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight shared_ptr light_ptr = make_shared(213, 343, 227, 332, 554, 0); hittable_pdf p0(light_ptr, rec.p); cosine_pdf p1(rec.normal); mixture_pdf p(&p0, &p1); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ scattered = ray(rec.p, p.generate(), r.time()); pdf_val = p.value(scattered.direction()); return emitted + albedo * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, lights, depth-1) / pdf_val; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-mixture]: [main.cc] The ray_color function, using mixture PDF]

1000 samples per pixel yields: 

So far I have the `ray_color()` function create two hard-coded PDFs: 1. `p0()` related to the shape of the light 2. `p1()` related to the normal vector and type of surface

We can redesign `material` and stuff all the new arguments into a `struct` like we did for `hittable`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight struct scatter_record { ray specular_ray; bool is_specular; vec3 attenuation; shared_ptr pdf_ptr; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class material { public: virtual vec3 emitted( ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight const ray& r_in, const hit_record& rec, double u, double v, const vec3& p ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ ) const { return vec3(0,0,0); } virtual bool scatter( ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight const ray& r_in, const hit_record& rec, scatter_record& srec ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ ) const { return false; } virtual double scattering_pdf( const ray& r_in, const hit_record& rec, const ray& scattered ) const { return 0; } }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [material-refactor]: [material.h] Refactoring the material class]

The Lambertian material becomes simpler: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class lambertian : public material { public: lambertian(shared_ptr a) : albedo(a) {} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight bool scatter(const ray& r_in, const hit_record& rec, scatter_record& srec) const { srec.is_specular = false; srec.attenuation = albedo->value(rec.u, rec.v, rec.p); srec.pdf_ptr = new cosine_pdf(rec.normal); return true; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ double scattering_pdf( const ray& r_in, const hit_record& rec, const ray& scattered ) const { auto cosine = dot(rec.normal, unit_vector(scattered.direction())); return cosine < 0 ? 0 : cosine/pi; } public: shared_ptr albedo; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [lambertian-scatter]: [material.h] New lambertian scatter() method]

And `ray_color()` changes are small: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color( const ray& r, const vec3& background, const hittable& world, shared_ptr lights, int depth ) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight scatter_record srec; vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p); if (!rec.mat_ptr->scatter(r, rec, srec)) return emitted; auto light_ptr = make_shared(lights, rec.p); mixture_pdf p(light_ptr, srec.pdf_ptr); ray scattered = ray(rec.p, p.generate(), r.time()); auto pdf_val = p.value(scattered.direction()); return emitted + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, lights, depth-1) / pdf_val; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-scatter]: [main.cc] Ray color with scatter]

We have not yet dealt with specular surfaces, nor instances that mess with the surface normal, and we have added a memory leak by calling `new` in Lambertian material. But this design is clean overall, and those are all fixable. For now, I will just fix `specular`. Metal is easy to fix. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ class metal : public material { public: metal(const vec3& a, double f) : albedo(a), fuzz(f < 1 ? f : 1) {} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight virtual bool scatter( const ray& r_in, const hit_record& rec, scatter_record& srec ) const { vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal); srec.specular_ray = ray(rec.p, reflected+fuzz*random_in_unit_sphere()); srec.attenuation = albedo; srec.is_specular = true; srec.pdf_ptr = 0; return true; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ public: vec3 albedo; double fuzz; }; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [metal-scatter]: [material.h] The metal class scatter method]

`ray_color()` just needs a new case to generate an implicitly sampled ray: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ vec3 ray_color( const ray& r, const vec3& background, const hittable& world, shared_ptr lights, int depth ) { hit_record rec; // If we've exceeded the ray bounce limit, no more light is gathered. if (depth <= 0) return vec3(0,0,0); // If the ray hits nothing, return the background color. if (!world.hit(r, 0.001, infinity, rec)) return background; scatter_record srec; vec3 emitted = rec.mat_ptr->emitted(r, rec, rec.u, rec.v, rec.p); if (!rec.mat_ptr->scatter(r, rec, srec)) return emitted; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight if (srec.is_specular) { return srec.attenuation * ray_color(srec.specular_ray, background, world, lights, depth-1); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ shared_ptr light_ptr = make_shared(lights, rec.p); mixture_pdf p(light_ptr, srec.pdf_ptr); ray scattered = ray(rec.p, p.generate(), r.time()); auto pdf_val = p.value(scattered.direction()); delete srec.pdf_ptr; return emitted + srec.attenuation * rec.mat_ptr->scattering_pdf(r, rec, scattered) * ray_color(scattered, background, world, lights, depth-1) / pdf_val; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [ray-color-implicit]: [main.cc] Ray color function with implicitly-sampled rays]

We also need to change the block to metal. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ hittable_list cornell_box(camera& cam, double aspect) { hittable_list world; auto red = make_shared(make_shared(vec3(0.65, 0.05, 0.05))); auto white = make_shared(make_shared(vec3(0.73, 0.73, 0.73))); auto green = make_shared(make_shared(vec3(0.12, 0.45, 0.15))); auto light = make_shared(make_shared(vec3(15, 15, 15))); world.add(make_shared(make_shared(0, 555, 0, 555, 555, green))); world.add(make_shared(0, 555, 0, 555, 0, red)); world.add(make_shared(make_shared(213, 343, 227, 332, 554, light))); world.add(make_shared(make_shared(0, 555, 0, 555, 555, white))); world.add(make_shared(0, 555, 0, 555, 0, white)); world.add(make_shared(make_shared(0, 555, 0, 555, 555, white))); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight shared_ptr aluminum = make_shared(vec3(0.8, 0.85, 0.88), 0.0); shared_ptr box1 = make_shared(vec3(0,0,0), vec3(165,330,165), aluminum); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ box1 = make_shared(box1, 15); box1 = make_shared(box1, vec3(265,0,295)); world.add(box1); shared_ptr box2 = make_shared(vec3(0,0,0), vec3(165,165,165), white); box2 = make_shared(box2, -18); box2 = make_shared(box2, vec3(130,0,65); world.add(box2); vec3 lookfrom(278, 278, -800); vec3 lookat(278, 278, 0); vec3 vup(0, 1, 0); auto dist_to_focus = 10.0; auto aperture = 0.0; auto vfov = 40.0; auto t0 = 0.0; auto t1 = 1.0; cam = camera(lookfrom, lookat, vup, vfov, aspect, aperture, dist_to_focus, t0, t1); return world; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [scene-cornell-al]: [main.cc] Cornell box scene with aluminum material]

The resulting image has a noisy reflection on the ceiling because the directions toward the box are not sampled with more density. 

We could make the PDF include the block. Let’s do that instead with a glass sphere because it’s easier. When we sample a sphere’s solid angle uniformly from a point outside the sphere, we are really just sampling a cone uniformly (the cone is tangent to the sphere). Let’s say the code has `theta_max`. Recall from the Generating Random Directions chapter that to sample $\theta$ we have: $$ r_2 = \int_{0}^{\theta} 2\pi \cdot f(t) \cdot \sin(t) dt $$ Here $f(t)$ is an as yet uncalculated constant $C$, so: $$ r_2 = \int_{0}^{\theta} 2\pi \cdot C \cdot \sin(t) dt $$ Doing some algebra/calculus this yields: $$ r_2 = 2\pi \cdot C \cdot (1-\cos(\theta)) $$

So $$ cos(\theta) = 1 - \frac{r_2}{2 \pi \cdot C} $$

We know that for $r_2 = 1$ we should get $\theta_{max}$, so we can solve for $C$: $$ \cos(\theta) = 1 + r_2 \cdot (\cos(\theta_{max})-1) $$

$\phi$ we sample like before, so: $$ z = \cos(\theta) = 1 + r_2 \cdot (\cos(\theta_{max}) - 1) $$ $$ x = \cos(\phi) \cdot \sin(\theta) = \cos(2\pi \cdot r_1) \cdot \sqrt{1-z^2} $$ $$ y = \sin(\phi) \cdot \sin(\theta) = \sin(2\pi \cdot r_1) \cdot \sqrt{1-z^2} $$

Now what is $\theta_{max}$? ![Figure [sphere-cone]: A sphere enclosing cone](../images/fig.sphere-cone.jpg)

We can see from the figure that $\sin(\theta_{max}) = R / length(\mathbf{c} - \mathbf{p})$. So: $$ \cos(\theta_{max}) = \sqrt{1 - \frac{R^2}{length^2(\mathbf{c} - \mathbf{p})}} $$

We also need to evaluate the PDF of directions. For directions toward the sphere this is $1/solid\_angle$. What is the solid angle of the sphere? It has something to do with the $C$ above. It, by definition, is the area on the unit sphere, so the integral is $$ solid\_angle = \int_{0}^{2\pi} \int_{0}^{\theta_{max}} \sin(\theta) = 2 \pi \cdot (1-\cos(\theta_{max})) $$

The sphere class needs the two PDF-related functions: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ double sphere::pdf_value(const vec3& o, const vec3& v) const { hit_record rec; if (!this->hit(ray(o, v), 0.001, infinity, rec)) return 0; auto cos_theta_max = sqrt(1 - radius*radius/(center-o).length_squared()); auto solid_angle = 2*pi*(1-cos_theta_max); return 1 / solid_angle; } vec3 sphere::random(const vec3& o) const { vec3 direction = center - o; auto distance_squared = direction.length_squared(); onb uvw; uvw.build_from_w(direction); return uvw.local(random_to_sphere(radius, distance_squared)); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [sphere-pdf]: [sphere.h] Sphere with PDF]

With the utility function: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ inline vec3 random_to_sphere(double radius, double distance_squared) { auto r1 = random_double(); auto r2 = random_double(); auto z = 1 + r2*(sqrt(1-radius*radius/distance_squared) - 1); auto phi = 2*pi*r1; auto x = cos(phi)*sqrt(1-z*z); auto y = sin(phi)*sqrt(1-z*z); return vec3(x, y, z); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [rand-to-sphere]: [pdf.h] The random_to_sphere utility function]

We can first try just sampling the sphere rather than the light: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ shared_ptr light_shape = make_shared(213, 343, 227, 332, 554, 0); shared_ptr glass_sphere = make_shared(vec3(190, 90, 190), 90, 0); for (int j = image_height-1; j >= 0; --j) { std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush; for (int i = 0; i < image_width; ++i) { vec3 col(0, 0, 0); for (int s=0; s < ns; ++s) { auto u = (i + random_double()) / image_width; auto v = (j + random_double()) / image_height; ray r = cam->get_ray(u, v); col += ray_color(r, background, world, glass_sphere, max_depth); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [sampling-sphere]: [main.cc] Sampling just the sphere]

This yields a noisy box, but the caustic under the sphere is good. It took five times as long as sampling the light did for my code. This is probably because those rays that hit the glass are expensive! 

We should probably just sample both the sphere and the light. We can do that by creating a mixture density of their two densities. We could do that in the `ray_color()` function by passing a list of hittables in and building a mixture PDF, or we could add PDF functions to `hittable_list`. I think both tactics would work fine, but I will go with instrumenting `hittable_list`. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ double hittable_list::pdf_value(const vec3& o, const vec3& v) const { auto weight = 1.0/objects.size(); auto sum = 0.0; for (const auto& object : objects) sum += weight * object->pdf_value(o, v); return sum; } vec3 hittable_list::random(const vec3& o) const { auto int_size = static_cast(objects.size()); return objects[random_int(0, int_size-1)]->random(o); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [density-mixture]: [hittable_list.h] Creating a mixture of densities]

We assemble a list to pass to `ray_color()` `from main()`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ hittable_list lights; lights.add(make_shared(213, 343, 227, 332, 554, 0)); lights.add(make_shared(vec3(190, 90, 190), 90, 0)); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [scene-density-mixture]: [main.cc] Updating the scene]

And we get a decent image with 1000 samples as before: 

An astute reader pointed out there are some black specks in the image above. All Monte Carlo Ray Tracers have this as a main loop: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ pixel_color = average(many many samples) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

So big decision: sweep this bug under the rug and check for `NaN`s, or just kill `NaN`s and hope this doesn't come back to bite us later. I will always opt for the lazy strategy, especially when I know floating point is hard. First, how do we check for a `NaN`? The one thing I always remember for `NaN`s is that any `if` test with a `NaN` in it is false. Using this trick, we update the `vec3::write_color()` function to replace any NaN components with zero: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ void write_color(std::ostream &out, int samples_per_pixel) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight // Replace NaN component values with zero. if (e[0] != e[0]) e[0] = 0.0; if (e[1] != e[1]) e[1] = 0.0; if (e[2] != e[2]) e[2] = 0.0; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ // Divide the color total by the number of samples and gamma-correct // for a gamma value of 2.0. auto scale = 1.0 / samples_per_pixel; auto r = sqrt(scale * e[0]); auto g = sqrt(scale * e[1]); auto b = sqrt(scale * e[2]); // Write the translated [0,255] value of each color component. out << static_cast(256 * clamp(r, 0.0, 0.999)) << ' ' << static_cast(256 * clamp(g, 0.0, 0.999)) << ' ' << static_cast(256 * clamp(b, 0.0, 0.999)) << '\n'; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [Listing [write-color-nan]: [vec3.h] NaN-tolerant write_color function]

Happily, the black specks are gone: