Depth of field creates a uniformly blurry image

[typedrat]

I've completed the first book, and while I've mostly managed to get it working, the only issue that I'm having is with the depth of field implementation. My code is in Rust and at https://github.com/typedrat/rayromano, enabling the depth of field by setting the angle to be non-zero makes the entire image uniformly blurry.

[hollasch]

For the scene in question, I believe the focus distance should be 3.4. A quick glance through your code seems to show that everything else is ok.

[typedrat]

Checking again, and the settings in my repo match the settings in the book outside of accidentally committing when I halved the defocus angle as a test.

[hollasch]

Hmmm. I looked through things again, and didn't find anything that jumped out at me. Looks like it's debugger time.

[typedrat]

With a bit of examination, I think I've seen the issue:

Kolmogorov-Smirnov test (X): statistic=0.0022331, p-value=5.7323e-18
Kolmogorov-Smirnov test (Y): statistic=0.00043753, p-value=0.42007
Kolmogorov-Smirnov test (Z): statistic=0.00035296, p-value=0.69385

Anderson-Darling test (X): statistic=16.72209439676492, pvalue=0.001
Anderson-Darling test (Y): statistic=-0.15825116476130555, pvalue=0.25
Anderson-Darling test (Z): statistic=-0.6384637105655141, pvalue=0.25

Cramér-von Mises test (X): statistic=8.990666169673204, pvalue=2.6424729071550246e-10
Cramér-von Mises test (Y): statistic=0.12550546322017908, pvalue=0.4736490754443351
Cramér-von Mises test (Z): statistic=0.07382417237386107, pvalue=0.7283156858079022

[typedrat]

Okay, trying a definitely good implementation of sampling the unit disk:

pub fn random_in_unit_disk() -> Vector3<f64> {
    let theta = fastrand::f64() * TAU;
    let r = fastrand::f64().sqrt();

    Vector3::new(r * theta.cos(), r * theta.sin(), 0.)
}

and confirming that the defocus_disk_u and defocus_disk_v vectors are correct. I'm officially stumped.

[hollasch]

I would eliminate all jitter at the pixel location if you haven't done that already.

[typedrat]

Still about the same, hmm.

[armansito]

I believe the issue is in src/camera.rs in Camera::get_ray:

    fn get_ray(&self, x: f64, y: f64) -> Ray {
        let offset = sample_for_pixel();
        let pixel_center = self.pixel_0_0_at()
            + (x + offset.x) * self.viewport_delta_u()
            + (y + offset.y) * self.viewport_delta_v();

        let ray_origin = if self.defocus_angle <= 0. {
            self.look_from
        } else {
            self.defocus_disk_sample()
        };
        let ray_direction = pixel_center - ray_origin;

        Ray::new(self.look_from, ray_direction)
    }

The origin of the ray is initialized as self.look_from rather than ray_origin. Since ray_direction itself is computed as pixel_center - ray_origin, using the unjittered ray origin amounts to perturbing the ray direction away from pixel_center, resulting in a regular blur.

[typedrat]

... oh hell

[typedrat]

It's now resolved, thanks so much to @armansito!