Lambertian correct?

[oliverbestmann]

The book talks about how the directions of the outgoing reflection of light follows a lambertian distribution (normal + unit_circle). It then goes in to calculate the incoming ray based on that formula. Does that make sense?
Isn't the incoming direction totally independend of the outgoing direction for a lambertian material? I mean the light can come from anywhere, and as such, shouldn't the hemisphere method be actually the correct way to calculate the incoming ray?

[LPEdwin]

Although late.
My understanding is there is a Lambertian Law and a Lambertian Shader/Brdf/Material.

The cosine factor comes from the Lambertian Law and is about energy reduction depending on the angle (or projection area).
This is actually formally baked directly into the Rendering Equation.
But most implementations move the factor into the material implementation. Which means every material somehow handles the cosine factor.

The Lambertian material is an idealized material where the outgoing radiance in every direction is the same. (The Brdf function is constant.)
Now there are different ways to implement this.
One is to generate a direction uniformly and multiply it with the cosine factor. Usually done in the material.
The other is to generate directions with a probability following a cosine probability and therefor not multiplying the direction with a cosine factor afterwards. This is what "normal+unit_circle" approximately does.

In Ray Tracing: The Rest of you life this is taken even further for educational reasons.
Here he generates cosine weighted directions to utilize and demonstrate importance sampling.
For the importance sampling not to be biased he has to divide by the pdf, the cosine factor, again.
But because of the Lambertian Law he also has to multiply with the cosine factor.
This leads to something like scatter_pdf/pdf which cancels out.
Although i think scatter_pdf is badly named as it isn't really a pdf value. (But this would only be relevant if you're doing the third book.)

[alexd6631]

I think the normal + unit_circle is a poor approximation of the cosine factor.
https://computergraphics.stackexchange.com/a/12965 someone argue that it will be give a factor of cosine * sine and not cosine.

We can have the intuition of that, if we consider than randomly sampling a sphere surface will have more values near the "equator" (pi/2) than the poles (0 and pi), by shfiting by the normal vector, the distribution will be centered around (pi/4) (ie points from the contact point to the equator) and while grazing angle will be less likely, so are angles near the normal, which is in contradiction with the cosine law.

[alexd6631]

I have digged down the rabbit hole, and I think this is the best explanation so far is given by @LPEdwin :

The Lambertian material is an idealized material where the outgoing radiance in every direction is the same. (The Brdf function is constant.)
Now there are different ways to implement this.
One is to generate a direction uniformly and multiply it with the cosine factor. Usually done in the material.
The other is to generate directions with a probability following a cosine probability and therefor not multiplying the direction with a cosine factor afterwards. This is what "normal+unit_circle" approximately does.

I think this part of the book 1 is very misleading :

Scattering reflected rays evenly about the hemisphere produces a nice soft diffuse model, but we can definitely do better. A more accurate representation of real diffuse objects is the Lambertian distribution. This distribution scatters reflected rays in a manner that is proportional to cos(𝜙)
, where 𝜙
is the angle between the reflected ray and the surface normal. This means that a reflected ray is most likely to scatter in a direction near the surface normal, and less likely to scatter in directions away from the normal. This non-uniform Lambertian distribution does a better job of modeling material reflection in the real world than our previous uniform scattering.

We use a cosine factor distribution, not to reproduce the lambertian law, which applies to radiant intensity and not radiance, but because at radiance level, we want to take account of the incidence angle of incoming light radiance. So we end up sampling with a "correct" cosine distribution, which will make lights near the normal contribute more than those with a larger theta, but not for the reason mentioned in the book.

Book 3 is better in this regard, because it goes on the BRDF lighting model in more detail.

[alexd6631]

Also I made some statistical simulation of the "normal+unit_circle", and a variant where the point are sampled inside the unit_sphere (not surface), both are pretty poor approximation of cos(theta) distribution.
This is consistent with the result in :
https://computergraphics.stackexchange.com/a/12965

import numpy as np
import matplotlib.pyplot as plt

N = 10000000

def sample_points_in_unit_sphere(N):
    points = np.random.uniform(low=-1, high=1, size=(N, 3))
    
    mask = np.sum(points**2, axis=1) <= 1
    points_in_sphere = points[mask]
    
    return points_in_sphere

def normalize_points(points):
    norms = np.linalg.norm(points, axis=1, keepdims=True)
    normalized_points = points / norms
    return normalized_points

def calculate_theta(points):
    theta = np.arccos(points[:, 2])
    return theta

def theta_inside_sphere():
    points_inside_sphere = sample_points_in_unit_sphere(N)
    points_with_offset = points_inside_sphere + np.array([0, 0, 1])
    normalized_points_with_offset = normalize_points(points_with_offset)
    return calculate_theta(normalized_points_with_offset)

def theta_on_sphere():
    points_inside_sphere = sample_points_in_unit_sphere(N)
    points_on_sphere = normalize_points(points_inside_sphere) + np.array([0, 0, 1])
    normalized_on_sphere = normalize_points(points_on_sphere)
    return calculate_theta(normalized_on_sphere)

plt.figure(figsize=(10, 6))
plt.hist([theta_inside_sphere(), theta_on_sphere()], bins=50, color=['skyblue', 'green'], edgecolor='black', alpha=0.7, label=['In sphere', 'On sphere'], density=True)

theta_range = np.linspace(0, np.pi /2, 1000)
cos_theta = np.cos(theta_range)

plt.plot(theta_range, cos_theta, color='red', label='cos(theta)')

plt.title(f"Theta angle {N} points")
plt.xlabel("Angle theta (radians)")
plt.ylabel("Density")
plt.grid(True)
plt.legend()
plt.show()

[alexd6631]

Still down the rabbit hole, but if someone read me, I want to correct my claim that the approximation was not good. Because it actually is.

My mistake was to consider that random cosine should give more rays near the normal, and was surprised by the histogram shape.
But I did not consider that for a uniform sampling across the hemisphere, the distribution will already be in sin(θ) (intuitively due to the pole being smaller than the equator). So if we apply a cosine factor, we will endup with cos(θ)sin(θ) which is what does the normal + unit_sphere_surface.

However, I still think the explanation of lambertian material is a bit misleading (although we end with the correct formula) since in terms of radiance/luminance the cosine factor comes from the incident light and not the material itself.