Lambertian Reflectance Model

easyFREEPhotometric StereoPhotometryCV: 3D Reconstruction

Compute the observed intensity under Lambertian (diffuse) reflectance.

The Lambertian reflectance model describes how light reflects from matte surfaces:

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

where:

$I$ is the observed intensity
$\rho$ is the surface albedo (reflectance) in range [0, 1]
$\mathbf{n}$ is the unit surface normal vector
$\mathbf{l}$ is the unit light direction vector
The dot product is clamped to non-negative (surfaces facing away get no light)

Key properties:

Intensity is maximum when $\mathbf{n} = \mathbf{l}$ (light directly overhead)
Intensity decreases as angle between normal and light increases
Intensity is zero when angle exceeds 90° (backlit surface)

Output format: return the intensity as a number. Whenever the intensity is zero (for example $\mathbf{n} \cdot \mathbf{l} \le 0$ ), return the integer 0, so it prints as 0 rather than 0.0.

Example

Input

lambertian(0.8, [0, 0, 1], [0, 0, 1])

Output

0.8

Reasoning

Inputs: albedo $\rho = 0.8$ means the surface reflects 80% of the incoming light. normal $\mathbf{n} = (0, 0, 1)$ points straight up out of the surface, and light_dir $\mathbf{l} = (0, 0, 1)$ points from the surface towards the light, also straight up.
Dot product: $\mathbf{n} \cdot \mathbf{l} = 0 \cdot 0 + 0 \cdot 0 + 1 \cdot 1 = 1$ . For unit vectors this is $\cos\theta$ , so $\theta = 0^\circ$ : the light hits the surface head on.
Clamp: $\max(0, 1) = 1$ , so nothing is cut off here.
Scale by albedo: $I = 0.8 \times 1 = 0.8$ , the sample output 0.8. This is the brightest this surface can ever look, since $\cos\theta \le 1$ .
Notice: if the light came from below, $\mathbf{l} = (0, 0, -1)$ , the dot product would be $-1$ . The clamp turns that into $0$ , so a backlit surface is black, not negatively bright. A light along $(0, 1, 0)$ grazes the surface at $90^\circ$ and also gives $0$ .

Constraints

albedo: surface reflectance in range [0, 1]
normal: unit surface normal [nx, ny, nz]
light_dir: unit light direction [lx, ly, lz]
Return intensity clamped to non-negative

Learn this in

3D ReconstructionCV Study Plan Image FormationCV Study Plan

More from CV: 3D Reconstruction

NeRF Ray Samplinghard Surface Integration from Normalsmedium Marching Cubes SDF to Meshmedium ICP Point Cloud Alignmenthard NeRF Positional Encodingmedium

Concept primer

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:

Compute the dot product between the given normal vector and light direction vector.
Clamp this dot product at 0 from below (no negative values).
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:

(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]

Compute dot product:

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

Clamp to non-negative:

dot_clamped = max(0.0, dot)

Multiply by albedo:

I = rho * dot_clamped

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.

solution.py

Python 3.13

Test results