Lambertian Reflectance Model

Here’s how to think about and implement this problem without jumping straight to code.

---

1. Background Knowledge

In computer vision and graphics, the Lambertian reflectance model is a simple model for how light reflects off an ideal matte (diffuse) surface. It assumes that the surface reflects light equally in all viewing directions, so the observed intensity depends only on the angle between the incoming light direction and the surface normal, not on where the camera is.

Given:

• unit surface normal $\mathbf{n}$,
• unit light direction $\mathbf{l}$ (typically pointing toward the light),
• surface albedo $\rho \in [0,1]$,

the Lambertian model says:

$$I = \rho \cdot \max(0, \mathbf{n} \cdot \mathbf{l})$$

The dot product $\mathbf{n} \cdot$\mathbf{l}$= \cos\theta$, where $\theta$ is the angle between normal and light. So:

• When light hits head-on ($\theta = 0$), $\cos$\theta$= 1$ → maximum intensity.
• As $\theta$ increases, $\cos\theta$ decreases → dimmer.
• When $\theta > 90^\circ$, $\cos$\theta$< 0$, but physically the surface is back-facing, so intensity is clamped to 0.

This model is a building block for photometric stereo, where multiple images under different known light directions are used to infer surface normals and albedo.

---

2. Algorithm / General Approach

For this specific task, the algorithm pattern is very simple:

1. Compute the dot product between the given normal vector and light direction vector.
2. Clamp this dot product at 0 from below (no negative values).
3. Multiply the clamped value by the given albedo $\rho$ to get the intensity.

Conceptually, it’s just “projection + clamp + scale.”

---

3. Step-by-Step Strategy

Assume you are given:

• rho (float),
• n as a 3D vector (e.g., [nx, ny, nz]),
• l as a 3D vector (e.g., [lx, ly, lz]), both already unit length in most problems of this type.

Steps:

1. (Optionally) Normalize n and l if the problem doesn’t guarantee they’re unit vectors:

def normalize(v):
length = math.sqrt(v**2 + v**2 + v**2)
return [v/length, v/length, v/length]

2. Compute dot product:

dot = n*l + n*l + n*l

3. Clamp to non-negative:

dot_clamped = max(0.0, dot)

4. Multiply by albedo:

I = rho * dot_clamped

5. Return/output I as the observed intensity.

If the problem uses arrays of normals or lights, you just apply this element-wise (possibly vectorized).

---

4. Common Pitfalls

• Forgetting to clamp: Using $I = \rho ($\mathbf{n}$\cdot$\mathbf{l}$)$ without max(0,...) can produce negative intensities, which are physically meaningless.
• Non-unit vectors: If $\mathbf{n}$ or $\mathbf{l}$ are not normalized, the dot product is not equal to $\cos\theta$, and intensities will be scaled incorrectly.
• Albedo range: Ensure $\rho$ is in [0,1] or as specified. If input can be outside, consider clamping or at least be aware.
• Floating point errors: Dot products of near-unit vectors can give values slightly above 1 or below -1 due to rounding (rare but can matter if you later use acos). For this simple intensity computation, it’s usually fine, but clamping with max(0, dot) already protects from small negative noise.

---

5. Time & Space Complexity

For a single intensity computation:

• Time complexity:

• Dot product: constant work (a few multiplications and additions).

• Clamp and multiply: constant work. So overall: $O(1)$.

• Space complexity:

• Uses a constant number of scalar variables; no extra significant memory. So overall: $O(1)$.

For $N$ pixels (e.g., per-pixel shading), it scales linearly:

• Time: $O(N)$
• Extra space: $O(N)$ if you store all intensities, or $O(1)$ if you compute and immediately output/accumulate.