2.4. Filter

The decoding yields the following results:

The brightness \(\hat{a}\) is a measure for the reflectance (resp. absorption) of the surface.

The modulation \(\hat{b}\) is a measure for the glossiness (resp. scattering) of the surface.

The registration \(\hat{x}\) is a mapping from camera pixels to screen positions \(\hat{x}\) (with subpixel accuracy). It contains the information where each camera pixel, i.e. each camera sight ray, looked onto the screen during the fringe pattern recording.

"""Decode fringe pattern sequence."""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()
I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

a, b, x = f.decode(I_rec)

# display first frame  and first color channel of each result
plt.figure("registration 'x'")
plt.imshow(x[0, :, :, 0])
plt.colorbar()
plt.figure("modulation 'b'")
plt.imshow(b[0, :, :, 0])
plt.colorbar()
plt.figure("brightness 'a'")
plt.imshow(a[0, :, :, 0])
plt.colorbar()
plt.show()

These results are in video shape, so for the brightness \(\hat{a}\) and the registration \(\hat{x}\), the usually two directions D are along the the first i.e. the time axis. For the modulation \(\hat{b}\), the modulation of the sets K of the directions D are flattened into the first dimension; you may reshape them as follows:

T, Y, X, C = b.shape
b = b.reshape(f.D, f.K, Y, X, C)

Fig. 2.11 Brightness.

Fig. 2.12 Modulation.

Fig. 2.13 Registration.

2.4.1. Direct and Global Illumination Component

The direct illumination component is just twice the measured modulation:

\(I_D = 2 \hat{b}\).

The global illumination component can be determined with

\(I_G = 2 (\hat{a} - \hat{b})\)

under the condition that the spatial frequency \(\nu\) is high enough [Nay06].

Both can be normalized into the range [0, 1) by dividing through the maximal possible gray value \(I_{max}\) of the recording camera.

"""Direct and global illumination component.
https://dl.acm.org/doi/abs/10.1145/1179352.1141977"""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()
f.v = 99, 100, 101  # spatial frequency 'v' must be high enough but still resolved by the recording camera

I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

res = f.decode(I_rec, verbose=True)

# make use of namedtuple:
a = res.brightness
b = res.modulation
x = res.registration
d = res.direct
g = res.glob

plt.figure("global 'g'")
plt.imshow(g[0, :, :, 0])
plt.colorbar()
plt.figure("direct 'd'")
plt.imshow(d[0, :, :, 0])
plt.colorbar()
plt.show()

Fig. 2.14 Direct illumination component.

Fig. 2.15 Global illumination component.

2.4.2. Visibility and Exposure

In an alternative formulation, the absolute quantities offset \(a\) and amplitude \(b\) of the phase shifting equation are replaced by the maximal possible gray value \(I_{max}\), the relative quantities exposure \(E\) (relative average intensity) and visibilty \(V\) (relative fringe contrast) [Fis12]:

\(I = a + b \cos(\varPhi) = I_{max} E [1 + V \cos(\varPhi)]\)

The two parameters \(E = \hat{a} / I_{max}\) and \(V = \hat{b_i} / \hat{a}\) describe the phase shifting signal \(I\) independently of the value range \([0, I_{max}]\) of the light source or camera. Both lie within the interval \([0, 1]\) with the additional condition \(E \le 1 / (1 + V)\); else, the radiance of the light source would be higher than the maximal possible value \(I_{max}\). Therefore, the valid values of \(V\) are limited for \(E > 0.5\). The optimal fringe contrast \(V = 1\) can be reached when \(E = 0.5\).

Fig. 2.16 Fringe pattern as a function of \(E\) and \(V\).

The advantage of this representation is the normalization of the descriptive parameters \(E\) and \(V\) and thereby the separation of additive and multiplicative influences.

The exposure \(E\) is affected by additional, constant light (not modulating the signal):

• the maximum brightness of the light source,

• the absorption of the sample

• the absorption of optical elements (e.g. filters),

• the exposure time and the aperture setting of the camera.

The visibility \(V\) of the fringes is influenced by:

• the maximum contrast of the light source

• the surface quality of the sample (roughness, scattering),

• the position of the sample with regard to focal plane of the lens (defocus and depth of field),

• the camera lens’ modulation transfer function,

• the camera’s resolution (the camera pixel size projected onto the light source acts as a low pass filter).

"""Visibility and Exposure."""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()
I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

res = f.decode(I_rec, verbose=True)

# make use of namedtuple:
a = res.brightness
b = res.modulation
x = res.registration
E = res.exposure
V = res.visibility

plt.figure("exposure 'E'")
plt.imshow(E[0, :, :, 0])
plt.colorbar()
plt.figure("visibility 'V'")
plt.imshow(V[0, :, :, 0])
plt.colorbar()
plt.show()

Fig. 2.17 Visibility.

Fig. 2.18 Exposure.

2.4.3. Verbose Results

Additionally to the already mentioned results brightness, modulation, registration, visibility and exposure, more intermediate and verbose results an be returned by setting the flag verbose in the method decode() to True:

"""Decode verbose results."""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()
I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

# decode and return additional results:
res = f.decode(I_rec, verbose=True)

# make use of namedtuple:
a = res.brightness
b = res.modulation
x = res.registration
p = res.phase
k = res.order
r = res.residuals
u = res.uncertainty

# display first frame of results
plt.figure("phase 'p'")
plt.imshow(p[0, :, :, 0])
plt.colorbar()
plt.figure("fringe order 'k'")
plt.imshow(k[0, :, :, 0])
plt.colorbar()
plt.figure("residuals 'r'")
plt.imshow(r[0, :, :, 0])
plt.colorbar()
plt.figure("uncertainty 'u'")
plt.imshow(u[0, :, :, 0])
plt.colorbar()
plt.show()

The phase … after temporal demodulation … link to fundamentals

Fig. 2.19 Phase.

---

The fringe order … spatial demodulation, i.e. unwrapping … link to fundamentals

Fig. 2.20 Fringe order.

---

The residuals … after optimization-based unwrapping … link to fundamentals

Fig. 2.21 Residuals.

---

The uncertainty … after temporal demodulation i.e. unwrapping … best/minimal uncertainty if ui is set and correct fringe orders are found … link to fundamentals

Fig. 2.22 Uncertainty.

2.4.4. Slope

If the deflectometric setup is calibrated, the slope of the surface can be computed from the registration.

“[Deflectometry] measures slopes (first order derivatives of the shape). The sensitivity to higher spatial frequencies is therefore amplified, resulting in excellent (sometimes excessive) sensitivity for small-scale irregularities and at the same time poor sensitivity and stability for low-order surface features.” [Bur23]

"""Slope."""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()

I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

a, b, x = f.decode(I_rec)

s = x  # todo: compute slope from calibrated setup

plt.figure("slope 'y'")
plt.imshow(s[1, :, :, 0])
plt.colorbar()
plt.figure("slope 'x'")
plt.imshow(s[0, :, :, 0])
plt.colorbar()
plt.show()

Fig. 2.23 Slope map in x-direction. From [SAC].

Fig. 2.24 Slope map in y-direction. From [SAC].

2.4.5. Curvature

“As an alternative use of [deflectometry] data, one may differentiate them and recover surface curvatures (combinations of second order shape derivatives […]. Unlike point positions and slopes, the latter are intrinsic local characteristics of the surface […] that are independent of its embedding in 3D space. As such, curvature maps are useful observables for various quality inspection tasks. Derivation of curvatures is less error-prone than shape integration and does not require accurate prior knowledge of the distance to the object.” [Bur23]

"""Curvature."""

import fringes as frng
import matplotlib.pyplot as plt

f = frng.Fringes()
I = f.encode()

I_rec = I  # todo: replace this line with recording data as in 'record.py'

a, b, x = f.decode(I_rec)

c = frng.curvature(x)

plt.figure("curvature 'c'")
plt.imshow(c[0, :, :, 0])
plt.colorbar()
plt.show()

Fig. 2.25 Curvature map. From [SAC].

[Bur23] (1,2)

Burke et al., “Deflectometry for specular surfaces: an overview”, Advanced Optical Technologies, 2023.

[Fis12]

Fischer et al., “Vorhersage des Phasenrauschens in optischen Messsystemen mit strukturierter Beleuchtung”, Technisches Messen, 2012.

[Nay06]

Nayar et al., “Fast separation of direct and global components of a scene using high frequency illumination”, SIGGRAPH, 2006.

[SAC] (1,2,3)

SAC Sirius Advanced Cybernetics GmbH, “trevista”, product information sheet, 2018.