Ground sphere from "Ray Tracing in a weekend" warps into the top of the image, resulting image looks like two spheres ~ one at top and one at bottom

[irrevocablesake]

You can reproduce this by exactly implementing code up till Section 5. Once you implement till the mentioned section, change the position of sphere from ( 0, 0, 0 ) to ( 0, -100.5, -1 ) and radius from 0.5 to 100. Let's refer to this big sphere as "ground"

My questions:

1. The logic seems sound, we have positioned the ground such that the rays from the lower half of the viewport hit the top area of the sphere. Then how do the top half of the viewport also get the hit on the ground

2. Is it related to viewport size / image dimensions?

3. Is it a bug? or is it an "after-product" of the so called "pin-hole" camera that we implement. If yes, I don't understand exactly why that happens

4. Surprisingly, once we implement Section 6.7 ~ the issue disappears. I don't understand how and why, because up till Section 5, we are just checking for hits and even if we just check for hits, we shouldn't get any "warping" or duplication of spheres

The setup would look something like this, all the files are same as the book's

• main.cpp
• ray.h
• vec3.h
• color.h

I will provide you main.cpp, just in case if I am doing anything wrong. Rest three files, one can take from the website

main.cpp

#include "color.h"
#include "ray.h"
#include "vec3.h"

#include <iostream>

bool hit_sphere(const point3& center, double radius, const ray& r) {
    vec3 oc = center - r.origin();
    auto a = dot(r.direction(), r.direction());
    auto b = -2.0 * dot(r.direction(), oc);
    auto c = dot(oc, oc) - radius*radius;
    auto discriminant = b*b - 4*a*c;
    return (discriminant >= 0);
}

color ray_color(const ray& r) {
    if (hit_sphere(point3(0,-100.5,-1), 100, r))
        return color(1, 0, 0);

    vec3 unit_direction = unit_vector(r.direction());
    auto a = 0.5*(unit_direction.y() + 1.0);
    return (1.0-a)*color(1.0, 1.0, 1.0) + a*color(0.5, 0.7, 1.0);
}

int main() {

    // Image

    auto aspect_ratio = 16.0 / 9.0;
    int image_width = 400;

    // Calculate the image height, and ensure that it's at least 1.
    int image_height = int(image_width / aspect_ratio);
    image_height = (image_height < 1) ? 1 : image_height;

    // Camera

    auto focal_length = 1.0;
    auto viewport_height = 2.0;
    auto viewport_width = viewport_height * (double(image_width)/image_height);
    auto camera_center = point3(0, 0, 0);

    // Calculate the vectors across the horizontal and down the vertical viewport edges.
    auto viewport_u = vec3(viewport_width, 0, 0);
    auto viewport_v = vec3(0, -viewport_height, 0);

    // Calculate the horizontal and vertical delta vectors from pixel to pixel.
    auto pixel_delta_u = viewport_u / image_width;
    auto pixel_delta_v = viewport_v / image_height;

    // Calculate the location of the upper left pixel.
    auto viewport_upper_left = camera_center
                             - vec3(0, 0, focal_length) - viewport_u/2 - viewport_v/2;
    auto pixel00_loc = viewport_upper_left + 0.5 * (pixel_delta_u + pixel_delta_v);

    // Render

    std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";

    for (int j = 0; j < image_height; j++) {
        std::clog << "\rScanlines remaining: " << (image_height - j) << ' ' << std::flush;
        for (int i = 0; i < image_width; i++) {
            auto pixel_center = pixel00_loc + (i * pixel_delta_u) + (j * pixel_delta_v);
            auto ray_direction = pixel_center - camera_center;
            ray r(camera_center, ray_direction);

            color pixel_color = ray_color(r);
            write_color(std::cout, pixel_color);
        }
    }

    std::clog << "\rDone.                 \n";
}

This is when i change the Y axis and position it even lower in Y axis

This is when i change the Z axis and position is further away from camera

Can someone shine some light on this? I am having a lot of trouble understanding this

[hollasch]

Compare against branch progression/1/2024/04-05. Each listing has its own commit in this history, and you can validate behavior there. I suspect that this will not show the effect you're experiencing. If so, it may help you find the issue in your implementation.

[irrevocablesake]

Thank you for the response @hollasch. I didn't compare the branches unfortunately, but after spending a lot of time. I realized what was causing the bug.

• If we just use code up until Section 5, and use the ground position / size. What's happening is that ~ the rays essentially intersect the sphere behind the camera, basically a -ve value of t. Which is not supposed to happen. Now, I realize ~ the author had mentioned

If you change your sphere center to z=+1
you will get exactly the same picture because this solution doesn't distinguish between objects in front of the camera and objects behind the camera. This is not a feature! We’ll fix those issues next.

• So, the author hadn't handled the case up until section 5 and the author handles that within Section 6.7 by using "intervals" and limiting t value from 0 to +INF

So, finally after spending 2 days on this bug ~ i finally understood the reason why it was not working! But I learned a lot 😄

[hollasch]

Glad you figured it out!