Rename refactor: num_samples to samples_per_pixel

Author: hollasch

books/RayTracingInOneWeekend.html

@@ -1240,9 +1240,9 @@
     [Listing [clamp]: <kbd>[rtweekend.h]</kbd> The clamp() utility function]
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void write_color(std::ostream &out, int num_samples) {
+    void write_color(std::ostream &out, int samples_per_pixel) {
         // Divide the color total by the number of samples.
-        auto scale = 1.0 / num_samples;
+        auto scale = 1.0 / samples_per_pixel;
         auto r = scale * e[0];
         auto g = scale * e[1];
         auto b = scale * e[2];
@@ -1263,7 +1263,7 @@
         int image_width = 200;
         int image_height = 100;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
-        int num_samples = 100;
+        int samples_per_pixel = 100;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
 
         std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";
@@ -1280,13 +1280,13 @@
             for (int i = 0; i < image_width; ++i) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
                 vec3 color(0, 0, 0);
-                for (int s = 0; s < num_samples; ++s) {
+                for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / image_width;
                     auto v = (j + random_double()) / image_height;
                     ray r = cam.get_ray(u, v);
                     color += ray_color(r, world);
                 }
-                color.write_color(std::cout, num_samples);
+                color.write_color(std::cout, samples_per_pixel);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
             }
         }
@@ -1427,7 +1427,7 @@
     int main() {
         int image_width = 200;
         int image_height = 100;
-        int num_samples = 100;
+        int samples_per_pixel = 100;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         int max_depth = 50;
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
@@ -1437,15 +1437,15 @@
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
                 vec3 color(0, 0, 0);
-                for (int s = 0; s < num_samples; ++s) {
+                for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / image_width;
                     auto v = (j + random_double()) / image_height;
                     ray r = cam.get_ray(u, v);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
                     color += ray_color(r, world, max_depth);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
                 }
-                color.write_color(std::cout, num_samples);
+                color.write_color(std::cout, samples_per_pixel);
             }
         }
 
@@ -1473,11 +1473,11 @@
 square-root:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void write_color(std::ostream &out, int num_samples) {
+    void write_color(std::ostream &out, int samples_per_pixel) {
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ highlight
         // Divide the color total by the number of samples and gamma-correct
         // for a gamma value of 2.0.
-        auto scale = 1.0 / num_samples;
+        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]);
@@ -1899,7 +1899,7 @@
     int main() {
         int image_width = 200;
         int image_height = 100;
-        int num_samples = 100;
+        int samples_per_pixel = 100;
         int max_depth = 50;
         std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";
 
@@ -1922,13 +1922,13 @@
             std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
             for (int i = 0; i < image_width; ++i) {
                 vec3 color(0, 0, 0);
-                for (int s = 0; s < num_samples; ++s) {
+                for (int s = 0; s < samples_per_pixel; ++s) {
                     auto u = (i + random_double()) / image_width;
                     auto v = (j + random_double()) / image_height;
                     ray r = cam.get_ray(u, v);
                     color += ray_color(r, world, max_depth);
                 }
-                color.write_color(std::cout, num_samples);
+                color.write_color(std::cout, samples_per_pixel);
             }
         }
 

books/RayTracingTheRestOfYourLife.html

@@ -2254,7 +2254,7 @@
 `vec3::write_color()` function to replace any NaN components with zero:
 
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++
-    void write_color(std::ostream &out, int num_samples) {
+    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;
@@ -2264,7 +2264,7 @@
 
         // Divide the color total by the number of samples and gamma-correct
         // for a gamma value of 2.0.
-        auto scale = 1.0 / num_samples;
+        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]);

src/InOneWeekend/main.cc

@@ -84,7 +84,7 @@ hittable_list random_scene() {
 int main() {
     int image_width = 1200;
     int image_height = 800;
-    int num_samples = 10;
+    int samples_per_pixel = 10;
     int max_depth = 50;
 
     std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
@@ -103,13 +103,13 @@ int main() {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
             vec3 color;
-            for (int s = 0; s < num_samples; ++s) {
+            for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
                 color += ray_color(r, world, max_depth);
             }
-            color.write_color(std::cout, num_samples);
+            color.write_color(std::cout, samples_per_pixel);
         }
     }
 

src/TheNextWeek/main.cc

@@ -348,7 +348,7 @@ hittable_list final_scene() {
 int main() {
     int image_width = 600;
     int image_height = 600;
-    int num_samples = 100;
+    int samples_per_pixel = 100;
     int max_depth = 50;
 
     std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
@@ -389,13 +389,13 @@ int main() {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
             vec3 color;
-            for (int s = 0; s < num_samples; ++s) {
+            for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
                 color += ray_color(r, world, max_depth);
             }
-            color.write_color(std::cout, num_samples);
+            color.write_color(std::cout, samples_per_pixel);
         }
     }
 

src/TheRestOfYourLife/main.cc

@@ -93,7 +93,7 @@ hittable_list cornell_box(camera& cam, double aspect) {
 int main() {
     int image_width = 600;
     int image_height = 600;
-    int num_samples = 100;
+    int samples_per_pixel = 100;
     int max_depth = 50;
 
     std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
@@ -110,13 +110,13 @@ int main() {
         std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
         for (int i = 0; i < image_width; ++i) {
             vec3 color;
-            for (int s = 0; s < num_samples; ++s) {
+            for (int s = 0; s < samples_per_pixel; ++s) {
                 auto u = (i + random_double()) / image_width;
                 auto v = (j + random_double()) / image_height;
                 ray r = cam.get_ray(u, v);
                 color += ray_color(r, world, lights, max_depth);
             }
-            color.write_color(std::cout, num_samples);
+            color.write_color(std::cout, samples_per_pixel);
         }
     }
 

src/common/vec3.h

@@ -53,7 +53,7 @@ class vec3 {
             return e[0]*e[0] + e[1]*e[1] + e[2]*e[2];
         }
 
-        void write_color(std::ostream &out, int num_samples) {
+        void write_color(std::ostream &out, int samples_per_pixel) {
             // Replace NaN component values with zero.
             // See explanation in Ray Tracing: The Rest of Your Life.
             if (e[0] != e[0]) e[0] = 0.0;
@@ -62,7 +62,7 @@ class vec3 {
 
             // Divide the color total by the number of samples and gamma-correct
             // for a gamma value of 2.0.
-            auto scale = 1.0 / num_samples;
+            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]);