Math notation update: book 2

Points are uppercase bold, vectors are lowercase bold, no barb.

Author: hollasch

books/RayTracingTheNextWeek.html

@@ -409,9 +409,9 @@
 </div>
 
 <div class='together'>
-Note that the blue and red bounding volumes are contained in the purple one, but they might
-overlap, and they are not ordered -- they are just both inside. So the tree shown on the right has
-no concept of ordering in the left and right children; they are simply inside. The code would be:
+Note that the blue and red bounding volumes are contained in the purple one, but they might overlap,
+and they are not ordered -- they are just both inside. So the tree shown on the right has no concept
+of ordering in the left and right children; they are simply inside. The code would be:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     if (hits purple)
@@ -439,9 +439,9 @@
 
 <div class='together'>
 Most people use the “slab” method. This is based on the observation that an n-dimensional AABB is
-just the intersection of n axis-aligned intervals, often called “slabs” An interval is just
-the points between two endpoints, _e.g._, $x$ such that $3 < x < 5$, or more succinctly $x$ in
-$(3,5)$. In 2D, two intervals overlapping makes a 2D AABB (a rectangle):
+just the intersection of n axis-aligned intervals, often called “slabs” An interval is just the
+points between two endpoints, _e.g._, $x$ such that $3 < x < 5$, or more succinctly $x$ in $(3,5)$.
+In 2D, two intervals overlapping makes a 2D AABB (a rectangle):
 
   ![Figure [2daabb]: 2D axis-aligned bounding box](../images/fig.2daabb.jpg)
 
@@ -459,29 +459,28 @@
 <div class='together'>
 In 3D, those boundaries are planes. The equations for the planes are $x = x_0$, and $x = x_1$. Where
 does the ray hit that plane? Recall that the ray can be thought of as just a function that given a
-$t$ returns a location $p(t)$:
+$t$ returns a location $\mathbf{P}(t)$:
 
-  $$ p(t) = \mathbf{a} + t \vec{\mathbf{b}} $$
+  $$ \mathbf{P}(t) = \mathbf{A} + t \mathbf{b} $$
 </div>
 
 <div class='together'>
-That equation applies to all three of the x/y/z coordinates. For example,
-$x(t) = \mathbf{a}_x + t \vec{\mathbf{b}}_x$. This ray hits the plane $x = x_0$ at the $t$ that
-satisfies this equation:
+That equation applies to all three of the x/y/z coordinates. For example, $x(t) = A_x + t b_x$. This
+ray hits the plane $x = x_0$ at the $t$ that satisfies this equation:
 
-  $$ x_0 = \mathbf{a}_x + t_0 \vec{\mathbf{b}}_x $$
+  $$ x_0 = A_x + t_0 b_x $$
 </div>
 
 <div class='together'>
 Thus $t$ at that hitpoint is:
 
-  $$ t_0 = \frac{x_0 - \mathbf{a}_x}{\vec{\mathbf{b}}_x} $$
+  $$ t_0 = \frac{x_0 - A_x}{b_x} $$
 </div>
 
 <div class='together'>
 We get the similar expression for $x_1$:
 
-  $$ t_1 = \frac{x_1 - \mathbf{a}_x}{\vec{\mathbf{b}}_x} $$
+  $$ t_1 = \frac{x_1 - A_x}{b_x} $$
 </div>
 
 <div class='together'>
@@ -526,31 +525,30 @@
 as long as we make it reasonably fast, so let’s go for simplest, which is often fastest anyway!
 First let’s look at computing the intervals:
 
-  $$ t_{x0} = \frac{x_0 - \mathbf{a}_x}{\vec{\mathbf{b}}_x} $$
-  $$ t_{x1} = \frac{x_1 - \mathbf{a}_x}{\vec{\mathbf{b}}_x} $$
+  $$ t_{x0} = \frac{x_0 - A_x}{b_x} $$
+  $$ t_{x1} = \frac{x_1 - A_x}{b_x} $$
 </div>
 
 <div class='together'>
-One troublesome thing is that perfectly valid rays will have $\vec{\mathbf{b}}_x = 0$, causing
-division by zero. Some of those rays are inside the slab, and some are not. Also, the zero will have
-a ± sign under IEEE floating point. The good news for $\vec{\mathbf{b}}_x = 0$ is that $t_{x0}$ and
-$t_{x1}$ will both be +∞ or both be -∞ if not between $x_0$ and $x_1$. So, using min and max should
-get us the right answers:
+One troublesome thing is that perfectly valid rays will have $b_x = 0$, causing division by zero.
+Some of those rays are inside the slab, and some are not. Also, the zero will have a ± sign under
+IEEE floating point. The good news for $b_x = 0$ is that $t_{x0}$ and $t_{x1}$ will both be +∞ or
+both be -∞ if not between $x_0$ and $x_1$. So, using min and max should get us the right answers:
 
   $$ t_{x0} = \min(
-     \frac{x_0 - \mathbf{a}_x}{\vec{\mathbf{b}}_x},
-     \frac{x_1 - \mathbf{a}_x}{\vec{\mathbf{b}}_x})
+     \frac{x_0 - A_x}{b_x},
+     \frac{x_1 - A_x}{b_x})
   $$
 
   $$ t_{x1} = \max(
-     \frac{x_0 - \mathbf{a}_x}{\vec{\mathbf{b}}_x},
-     \frac{x_1 - \mathbf{a}_x}{\vec{\mathbf{b}}_x})
+     \frac{x_0 - A_x}{b_x},
+     \frac{x_1 - A_x}{b_x})
   $$
 </div>
 
-The remaining troublesome case if we do that is if $\vec{\mathbf{b}}_x = 0$ and either
-$x_0 - \mathbf{a}_x = 0$ or $x_1 - \mathbf{a}_x = 0$ so we get a `NaN`. In that case we can probably
-accept either hit or no hit answer, but we’ll revisit that later.
+The remaining troublesome case if we do that is if $b_x = 0$ and either $x_0 - A_x = 0$ or $x_1 -
+A_x = 0$ so we get a `NaN`. In that case we can probably accept either hit or no hit answer, but
+we’ll revisit that later.
 
 <div class='together'>
 Now, let’s look at that overlap function. Suppose we can assume the intervals are not reversed (so
@@ -809,15 +807,15 @@
 but that is for speed not correctness. I’ll choose the middle ground, and at each node split the
 list along one axis. I’ll go for simplicity:
 
-1. randomly choose an axis
-2. sort the primitives using library qsort
-3. put half in each subtree
+  1. randomly choose an axis
+  2. sort the primitives using library qsort
+  3. put half in each subtree
 
 </div>
 
 <div class='together'>
 When the list coming in is two elements, I put one in each subtree and end the recursion. The
-traverse algorithm should be smooth and not have to check for null pointers, so if I just have one
+traversal algorithm should be smooth and not have to check for null pointers, so if I just have one
 element I duplicate it in each subtree. Checking explicitly for three elements and just following
 one recursion would probably help a little, but I figure the whole method will get optimized later.
 This yields:
@@ -1228,8 +1226,7 @@
 </div>
 
 <div class='together'>
-Now if we create an actual texture that takes these floats between 0 and 1 and creates grey
-colors:
+Now if we create an actual texture that takes these floats between 0 and 1 and creates grey colors:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     #include "perlin.h"
@@ -1710,7 +1707,7 @@
 </div>
 
 <div class='together'>
-The $atan2$ returns in the range $-\pi$ to $\pi$ so we need to take a little care there.
+The $atan2$ returns values in the range $-\pi$ to $\pi$, so we need to take a little care there.
 The $\theta$ is more straightforward:
 
   $$ \theta = \text{asin}(z) $$
@@ -1746,9 +1743,9 @@
 Storing Texture Image Data
 ---------------------------
 Now we also need to create a texture class that holds an image. I am going to use my favorite image
-utility [stb_image][]. It reads in an image into a big array of unsigned char. These are just
-packed RGBs that each range 0..255 (black to full white). The `image_texture` class uses the
-resulting image data.
+utility [stb_image][]. It reads in an image into a big array of unsigned char. These are just packed
+RGBs with each component in the range [0,255] (black to full white). The `image_texture` class uses
+the resulting image data.
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     #include "rtweekend.h"
@@ -1813,9 +1810,9 @@
     [Listing [img-texture]: <kbd>[texture.h]</kbd> Image texture class]
 
 <div class='together'>
-The representation of a packed array in that order is pretty standard. Thankfully, the
-[stb_image][] package makes that super simple -- just include the header `rtw_stb_image.h` (found in
-the project source code at `src/common/rtw_stb_image.h`) in `main.h`:
+The representation of a packed array in that order is pretty standard. Thankfully, the [stb_image][]
+package makes that super simple -- just include the header `rtw_stb_image.h` (found in the project
+source code at `src/common/rtw_stb_image.h`) in `main.h`:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     #include "rtw_stb_image.h"
@@ -1986,18 +1983,17 @@
 
 <div class='together'>
 To determine whether a ray hits such a rectangle, we first determine where the ray hits the plane.
-Recall that a ray $p(t) = \mathbf{a} + t \cdot \vec{\mathbf{b}}$ has its z component defined by
-$z(t) = \mathbf{a}_z + t \cdot \vec{\mathbf{b}}_z$. Rearranging those terms we can solve for what
-the t is where $z=k$.
+Recall that a ray $\mathbf{P}(t) = \mathbf{A} + t \mathbf{b}$ has its z component defined by $P_z(t)
+= A_z + t b_z$. Rearranging those terms we can solve for what the t is where $z=k$.
 
-  $$ t = \frac{k-\mathbf{a}_z}{\vec{\mathbf{b}}_z} $$
+  $$ t = \frac{k-A_z}{b_z} $$
 </div>
 
 <div class='together'>
 Once we have $t$, we can plug that into the equations for $x$ and $y$:
 
-  $$ x = \mathbf{a}_x + t \cdot \vec{\mathbf{b}}_x $$
-  $$ y = \mathbf{a}_y + t \cdot \vec{\mathbf{b}}_y $$
+  $$ x = A_x + t b_x $$
+  $$ y = A_y + t b_y $$
 </div>
 
 It is a hit if $x_0 < x < x_1$ and $y_0 < y < y_1$.
@@ -2258,9 +2254,9 @@
 This is very noisy because the light is small. But we have a problem: some of the walls are facing
 the wrong way. We haven't specified that a diffuse material should behave differently on different
 faces of the object, but what if the Cornell box had a different pattern on the inside and outside
-walls? The rectangle objects are described such that their front faces are always in the
-$(1, 0, 0)$, $(0, 1, 0)$, or $(0, 0, 1)$ directions. We need a way to switch the faces of an
-object. Let’s make a hittable that does nothing but hold another hittable, and flips the face:
+walls? The rectangle objects are described such that their front faces are always in the directions
+$(1,0,0)$, $(0,1,0)$, or $(0,0,1)$. We need a way to switch the faces of an object. Let’s make a
+hittable that does nothing but hold another hittable, and flips the face:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
     class flip_face : public hittable {
@@ -2933,6 +2929,11 @@
 
 
 
+[Markdeep]:  https://casual-effects/markdeep/
+[stb_image]: https://github.com/nothings/stb
+
+
+
 <!-- Markdeep: https://casual-effects.com/markdeep/ -->
 <link rel='stylesheet' href='../style/book.css'>
 <style class="fallback">body{visibility:hidden;white-space:pre;font-family:monospace}</style>