Book 1: Chapter 6.1: Is this algorithm correct?

[artogahr]

I'm trying to rewrite this book in Rust, and as far as I can tell, I've done everything 1:1 with the current published book (4.0.0-alpha.2, 2024-04-07)

As I can tell, within the older versions these lines:

raytracing.github.io/books/RayTracingInOneWeekend.html

Lines 680 to 683 in 891e5ac

	// 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);

Were represented as just a calculation for lower_left_corner.
Implementing the old version from reference implementations works. But the newer version, doesn't produce the colorful sphere.

Within my code, if I add an offset to the return value of the hit_sphere function, the sphere with the Vectors is reproduced with correct colors, i.e. instead of:

let t = hit_sphere(Point3::new(0.0, 0.0, -1.0), 0.5, r);
    if t > 0.0 {
        let n: Vec3 = (r.at(t) - Vec3::new(0.0, 0.0, -1.0)).normalized();
        return 0.5 * Color::new(n.x() + 1.0, n.y() + 1.0, n.z() + 1.0);
    }

doing

let t = hit_sphere(Point3::new(0.0, 0.0, -1.0), 0.5, r);
    if t > -0.5 {
        let n: Vec3 = (r.at(t) - Vec3::new(0.0, 0.0, -1.0)).normalized();
        return 0.5 * Color::new(n.x() + 1.0, n.y() + 1.0, n.z() + 1.0);
    }

fixes the issue and the exact image from the book is produced. Values between -0.5 and -0.27 produces different width circles. I'm not mathematically versed enough to understand why, but I thought this could help us diagnose this issue.

Any ideas?

[hollasch]

Looks like your hit_sphere() function isn't properly computing the oc variable (sphere center - ray origin).

For comparison, our book progression branches (which we use for validation and testing) are all under progression. For this case, see branch progression/1/2024-0405. From that branch, you'll find the commit you want to compare against: 9a502183 Listing 14 Ray-sphere intersection code (after). Check out that commit to see the working C++ code at the point of listing 14.

[artogahr]

Hi Steve, thank you very much for your response and converting the issue to the correct format.

Looks like your hit_sphere() function isn't properly computing the oc variable (sphere center - ray origin).

I've noticed that, the other implementer I followed did it the other way around (ray origin - center), but I didn't understand why at the time. Seeing they calculated lower_left_corner in the main file instead of viewport_upper_left as I saw in the book, I assumed they just kind of branched and did their own thing, that I could not understand.

If I switch them up and do it like (ray origin - center), I get a circle:

With this configuration, if I decrease the value t is compared to (just like before), I can get the circle to be thicker, up until around -0.5 where it becomes a solid filled circle, albeit with wrong colors:

The wrong colors indicate to me that (sphere center - ray origin) as is described in the current version of the published book is correct? Not sure.

Check out that commit to see the working C++ code at the point of listing 14.

I couldn't find the progression/1/2024-0405 branch unfortunately, maybe it's private to contributors?
I compared against a similar commit though:

Listing 14 Ray-sphere intersection code (after)
progression/1/2024-0404
cec6dfa
1 parent 85025c2

Here's how I updated my code:

pub fn hit_sphere(center: Point3, radius: f64, r: &Ray) -> f64 {
    let oc = center - r.origin();
    let a = r.direction().length_squared();
    let h = r.direction().dot(oc);
    let c = oc.length_squared() - radius.powi(2);
    let discriminant = h * h - a * c;

    if discriminant < 0.0 {
        -1.0
    } else {
        (h - discriminant.sqrt()) / a
    }
}

I checked out the main file from that commit, where the coordinates etc. are defined, and to me everything looks the same?

• https://github.com/RayTracing/raytracing.github.io/blob/cec6dfa9a80918c8553e329cb665d7019db28a43/src/InOneWeekend/main.cc
• https://github.com/artogahr/ray-tracer/blob/main/src/main.rs

Still though, I have to resort to t > -0.5 to get the sphere to show:

Of course I don't expect you to read through Rust and fix my issue, but if you confirm the algorithm itselfl is definitely correct in this, I'll try to take to Rust folks to figure out where I'm going wrong.

Thanks again

[armansito]

The bug is where you assign the ray origin in src/main.rs:

let r: Ray = Ray {
    orig: pixel_center,
    dir: ray_direction,
};

You need to initialize it to camera_center not pixel_center.

[artogahr]

@armansito, Me an my sphere's pretty colors thank you! :)