Exposure

Exposure is the amount of light a camera collects for one image, and by extension the settings that decide it: how long the sensor integrates (the shutter or exposure time), how wide the lens opening is (the aperture), and how strongly the collected signal is amplified (the gain, or ISO setting). Every frame a vision system receives was made with some choice of these three, and each choice has a cost: a long exposure smears moving objects, a short one collects few photons and is noisy, a wide aperture narrows the range of sharp depths, and too much light clips the brightest regions to a constant.

The optics behind the aperture and the whole chain from light to pixel value are described in image formation; the physics of the noise is in image noise. The sensor’s electronics (photosites, full well, readout and analog gain) belong to the image sensor, and combining several exposures to exceed one frame’s range belongs to high dynamic range imaging, introduced at the end.

Definition

In radiometric terms, the exposure of a pixel is the light energy per unit area that reaches it during one frame: the irradiance on the sensor integrated over the exposure time. The EMVA 1288 camera standard calls this the radiant exposure $H$ and builds its linear camera model on it (EMVA 1288, Eq. 1). In photographic usage the word also names the camera settings that produce it, and “an exposure” is simply one captured frame.

Three settings control the recorded brightness:

• Exposure time $t$ (often called shutter speed): how long the photosites collect light.
• Aperture, given as the f-number $N = f/d$, the focal length divided by the diameter of the opening: it sets how much of the light leaving the scene the lens passes.
• Gain: the amplification applied to the collected charge before or during digitization, set on photographic cameras through the ISO sensitivity.

The first two change how much light is collected; the third changes only how large the resulting numbers are.

Intuition

Think of each pixel as a bucket left out in the rain. The exposure time is how long the bucket stays out; the aperture is the width of a funnel above it; the gain is the scale on the ruler used to read the water level afterwards. Doubling the time or the funnel area doubles the water. Switching to a ruler with half-size marks doubles the reading but not the water: the reading’s random ripples, from drops that happened to fall or not, are doubled with it. If the bucket overflows, the reading stops at the brim no matter how hard it rained.

A bucket left out twice as long and one with a funnel twice as wide read the same level, but for a moving scene or one with depth the images differ: the longer collection smears motion and the wider funnel blurs out-of-focus depths. Choosing an exposure is choosing which defect a task can tolerate.

Formal Definition

For irradiance $E(\tau)$ on a pixel during an exposure that opens at time $0$, the radiant exposure is (EMVA 1288, Eq. 1)

$$H = \int_0^{t} E(\tau)\, d\tau ,$$

which is $H = E\,t$ when the light is steady. The irradiance a lens delivers from a scene of radiance $L$ falls with the square of the f-number, $E \propto L/N^2$, by the thin-lens irradiance formula given in image formation. The mean number of photons hitting a pixel of area $A$ is proportional to $H$ (EMVA 1288, Eq. 3), a fraction $\eta$ of them become electrons, and the camera turns electrons into digital numbers with an overall system gain $K$. Below saturation, the mean digital value is therefore

$$\mu_y = K\,(\mu_e + \mu_d), \qquad \mu_e \propto \eta\, L\, \frac{t}{N^2},$$

where $\mu_d$ is the dark signal (EMVA 1288, Section 2.1, Eqs. 5–6). The recorded brightness of a scene point scales with the product $K\,t/N^2$ of the three settings, and the value is clipped at the largest digital number. For video and still cameras that store processed images, a nonlinear response curve sits between $\mu_y$ and the stored value, but the light collected still depends on $t/N^2$ alone.

The Exposure Triangle

The three settings are often drawn as a triangle because any one of them can compensate for another. What differs is the side effect.

Exposure time

The exposure time directly controls the amount of light reaching the sensor, and for moving scenes it also sets the motion blur (Szeliski, 2022, Section 2.3). An object moving across the image at $v$ pixels per second is smeared over $v\,t$ pixels; it follows that halving $t$ halves the blur and the light together. Szeliski notes that a shorter exposure usually makes later analysis easier, while video meant for viewing may want some blur to avoid stroboscopic motion. Long exposures also collect more dark signal, which grows linearly with exposure time (EMVA 1288, Section 3.1).

Aperture

The aperture sets the light by its area: the irradiance scales with $1/N^2$, and the standard f-numbers (f/1.4, f/2, f/2.8, …) step by $\sqrt{2}$ so that each step halves the area, the same change in light as halving the exposure time (Szeliski, 2022, Section 2.2.3). Its side effects, a defocus blur inversely proportional to $N$ and diffraction blur at large $N$, are derived in image formation.

Gain and ISO

Before analog-to-digital conversion the sensed signal is boosted by an amplifier. Video cameras traditionally set this gain by automatic gain control, and still cameras expose it as the ISO setting, in ISO units such as 100, 200 or 400 (Szeliski, 2022, Section 2.3). The scale is proportional: Nikon’s manual for its Z6III camera (as of October 2026) describes a setting about 1 EV below ISO 100 as equivalent to ISO 50, so doubling the ISO number is one stop.

Gain amplifies the signal that was collected; it adds no light. Under the EMVA 1288 model the overall gain cancels out of the signal-to-noise ratio, apart from a small quantization effect (EMVA 1288, Section 2.6; image noise gives the model), so for a fixed read noise in electrons an image brightened by gain is as noisy relative to its signal as the dim image it came from. In real sensors part of the read noise can be added after the amplifier, so the read noise in electrons may fall somewhat at higher gain, while the room before clipping shrinks; the image sensor article describes both.

Reciprocity

Because the collected light depends only on $t/N^2$, any pair of settings with the same ratio collects the same light: f/4 for 1/250 s, f/2.8 for 1/500 s and f/5.6 for 1/125 s all give nominally the same exposure (the marked f-numbers are rounded powers of $\sqrt{2}$). With gain included, settings with the same product $K\,t/N^2$ give the same mean output. This interchangeability is called reciprocity. Cameras use it directly: in Nikon’s programmed-auto mode the user can rotate a dial to pick among shutter–aperture combinations that the manual describes as producing the same exposure, the “flexible program” (Nikon, Z6III Online Manual, Exposure).

Reciprocity holds for the mean value of a linear sensor until it saturates. It does not hold for anything else: two reciprocal settings give the same mean but different motion blur, depth of field and noise, which is the point of choosing between them.

Exposure Value and Stops

Exposure changes are counted on a base-2 logarithmic scale. One stop, or one exposure value (EV), is a factor of two in the light reaching the sensor (Szeliski, 2022, Section 2.2.3); Szeliski (2022, Section 10.1.1) describes aperture and shutter speed as global multipliers on the incoming light, most conveniently measured in exposure values, which are $\log_2$ brightness ratios. The difference between two settings in stops is

$$\Delta = \log_2 \frac{t_1 / N_1^2}{t_2 / N_2^2} + \log_2 \frac{K_1}{K_2},$$

where the first term is the change in collected light and the second, added here by the same logic, the change in gain. Stops add: opening the aperture one stop and shortening the time one stop leaves the light unchanged. Cameras set and display these settings in fractions of a stop; the Nikon Z6III, for example, moves ISO and exposure compensation in steps of 1/3 EV by default (Nikon, Z6III Online Manual, Exposure; ISO Sensitivity).

For vision this relative form is the useful one. A frame-to-frame change of $\Delta$ stops multiplies every linear pixel value by $2^{\Delta}$, which is exactly the kind of change that breaks intensity matching between frames.

Metering

A camera chooses an exposure by metering: measuring the light coming from the scene and setting $t$, $N$ and $K$ so that a summary of the measured values lands on a target. The summary varies. Photographic cameras offer several metering modes; the Nikon Z6III manual (as of October 2026) lists matrix metering, which sets exposure from tone distribution, colour, composition and distance over a wide area; centre-weighted metering, which gives most weight to the centre of the frame; spot metering of a circle covering about 1.5% of the frame at the focus point; and highlight-weighted metering, which weights the brightest areas to keep highlight detail (Nikon, Z6III Online Manual, Metering). Basler’s machine-vision cameras, for example, drive the average grey value of the chosen regions to a target brightness (Basler, Exposure Auto).

A meter measures the light a surface sends to the camera, which is reflectance times illumination, and cannot separate the two. It follows that a meter driving a scene’s average to a fixed middle value assumes the scene averages out to a middle grey. When it does not, the result is predictable:

• Bright scenes such as snow or a white wall are driven down to the target and come out grey; a dark subject in them is pushed into the noise.
• Dark scenes such as a part on black velvet or a night street are driven up, so the subject is overexposed and small bright parts clip.

Two remedies exist. Exposure compensation shifts the result by a chosen number of EV; the Nikon Z6III allows −5 to +5 EV for stills (Nikon, Z6III Online Manual, Exposure). Metering a region of interest that contains the subject instead of the whole frame removes the dependence on the background; spot metering does this in photography, and the auto function ROI, described below, on machine-vision cameras. The second example below shows both failures and the ROI fix on rendered scenes.

Auto-Exposure as a Control Loop

On a video or machine-vision camera, automatic exposure (AE) runs continuously: it measures each frame, compares the measurement with the target and adjusts the settings for a later frame. This makes it a feedback controller, with the behaviour of one.

The loop

A simple controller works in stops. If frame $n$ has metered value $m_n$ and the target is $T$, the error is $e_n = \log_2(m_n / T)$ stops, and the controller moves the exposure time by a fraction $k$ of it:

$$\log_2 t_{n+1} = \log_2 t_n - k\, e_n .$$

On a linear sensor without clipping, $m_n$ is proportional to $t_n$, so the error after one update is $(1 - k)\,e_n$: $k = 1$ corrects any error in one frame, and $0 < k < 1$ approaches the target geometrically. Two things spoil this ideal.

• Latency. A new setting takes effect a frame or more after it is computed; Basler’s documentation notes that the auto function takes effect with a short delay and that the first few images may be unaffected (Basler, Exposure Auto). With a one-frame delay, the error obeys $e_{n+2} = e_{n+1} - k\,e_n$, whose characteristic equation $z^2 - z + k = 0$ has roots of magnitude $\sqrt{k}$ once $k > 1/4$. It follows (this is a derivation for the simple controller above, not a property of any camera) that the response overshoots and oscillates for $k > 1/4$, and that the oscillation no longer decays at $k = 1$, the setting that was ideal without delay.
• Clipping. When much of the frame saturates, the measured mean underestimates how bright the scene is, so the controller underestimates the correction and needs extra frames.

A camera that oscillates around its target, brightening and darkening on alternate frames, is said to hunt; this is a property of the loop, separate from the flicker of the lights, below. Manufacturers give the loop limits and damping: Basler’s documentation describes lower and upper limits on the exposure times the controller may choose and, on some camera models, a damping factor with which the target is reached more slowly (Basler, Exposure Auto).

Modes, lock and priorities

The GenICam Standard Features Naming Convention, which standardizes feature names across machine-vision cameras, defines automatic exposure with three values: Off, where the user sets the exposure time; Once, where the device adapts the exposure once and returns to Off when it has converged; and Continuous, where it adapts all the time. It leaves the algorithm device-specific (SFNC 2.8, Section 5.7.5). Basler’s implementation of Once stops after the target is reached or after at most 30 calculation cycles (Basler, Exposure Auto). Once, followed by a fixed setting, is the machine-vision counterpart of the autoexposure lock on photographic cameras, which holds the exposure so it does not change with composition or subject brightness (Nikon, Z6III Online Manual, Exposure).

When both exposure time and gain are automatic, the controller needs a rule for which to change first. Basler’s auto function profiles include keeping gain as low as possible (raising the exposure time first, then gain once the time reaches its upper limit), keeping exposure time as low as possible, and, on some models, anti-flicker profiles for 50 Hz and 60 Hz lighting (Basler, Auto Function Profile). For a vision system the first protects against noise and the second against motion blur; which is right depends on the task, as the first example below shows.

Region of interest

A machine-vision camera can meter only part of its sensor. Basler’s auto function ROIs are rectangles, set independently of the image ROI that is read out, whose pixel data drive the auto functions; several can be defined, and only the part that overlaps the image ROI is used (Basler, Auto Function ROI). Pointing one at a conveyor lane, a road surface or an inspected part removes the metering failures above.

Metrics other than the mean

Robotics researchers have argued that the mean is the wrong thing to control. Zhang, Forster and Scaramuzza (2017) chose the exposure time that maximizes a gradient-based image-quality metric, using the camera’s photometric response function to compute the metric’s derivative with respect to exposure time. They reported that it outperformed the camera’s built-in auto-exposure in tests in several real environments, and that it improved a visual odometry pipeline (SVO) in high-dynamic-range environments. Shin et al. (2019) combined gradient, entropy and a noise estimate into one metric and searched exposure time and gain jointly with the Nelder–Mead method; on their own stereo dataset of static scenes, captured at a grid of exposure times and gains, they reported that the camera’s built-in AE often chose underexposed images outdoors because of sunlight, and that metrics ignoring noise often picked saturated or noisy images.

Clipping, Saturation and Histograms

A pixel’s digital output has a ceiling, the maximum digital value ($2^b - 1$ for a $b$-bit camera). EMVA 1288 defines the saturation capacity as the largest mean signal at which this clipping is still minor, which is normally below the physical full-well capacity because the output clips before the pixel fills (EMVA 1288, Section 2.7; the image sensor article gives the measurement). Beyond it, more and more pixels read the same maximum number. At the other end, values below the dark offset and noise floor carry little information about the scene.

Clipping destroys information that later processing cannot recover: a clipped region has no texture and no gradient, so it yields no features and no photometric constraint, and edges of clipped regions are where the scene crossed the ceiling rather than where an object ends. Clipping also biases averages, which matters to the metering loop above and to any method that compares mean intensities. The image histogram shows both problems directly, as mass piled against the lowest or highest value.

The ratio between the saturation exposure and the smallest exposure that still gives a signal-to-noise ratio of 1 is the sensor’s dynamic range (EMVA 1288, Section 2.7). A scene whose brightest and darkest parts that matter span more than that ratio cannot be captured in one frame: every exposure either clips the highlights or loses the shadows in noise.

Trade-offs for Vision

Each exposure setting buys image quality on one axis by spending it on another. For vision systems the main trades are these.

Motion blur against noise

Shortening the exposure time reduces blur in proportion, and raising the gain restores the brightness but not the photons, so noise grows relative to signal. Tracking, optical flow estimation, corner and keypoint detection and object detection suffer from both, in different ways: blur moves and widens edges along the motion direction and erases texture; noise adds false responses and jitters localization. The first example below measures this trade on a rendered moving scene.

Depth of field against light

Closing the aperture by one stop shrinks the defocus blur by a factor of $\sqrt{2}$ and halves the light, which must be paid back by doubling the exposure time (more motion blur) or the gain (more noise relative to signal), until diffraction limits the gain in sharpness. It follows that a set-up needing both a deep sharp range and short exposures has to add light.

Flickering lights under short exposures

Lamps run from the alternating-current grid flicker at twice the grid frequency: Sheinin, Schechner and Kutulakos (2017) show why for an idealized bulb whose light follows the square of the voltage, and the measured bulb responses they show (their Figure 2) all flicker at double the AC frequency, which gives 100 Hz on a 50 Hz grid and 120 Hz on a 60 Hz grid. If the light flickers at frequency $\nu$ as $\bar{I}\,[1 + m \cos(2\pi \nu \tau + \phi)]$, integrating it over an exposure that starts at $\tau_0$ gives (a short derivation)

$$H \propto \bar{I}\, t \left[ 1 + m\, \frac{\sin(\pi \nu t)}{\pi \nu t} \cos\!\big(2\pi \nu (\tau_0 + t/2) + \phi\big) \right].$$

An exposure much shorter than the flicker period sees the full modulation $m$, so frame brightness varies with the phase at which each frame happens to start; an exposure of a whole number of periods (10 ms at 100 Hz, about 8.3 ms at 120 Hz) averages it away. This is the effect anti-flicker modes address; Basler’s documentation says its 50 Hz and 60 Hz profiles optimize gain and exposure time to reduce it (Basler, Auto Function Profile). On a rolling-shutter sensor, rows start their exposures at different times, so the same formula predicts brightness bands across a single image.

Exposure changes between frames

Auto-exposure, by design, changes the brightness of the same scene point from frame to frame. Methods that assume brightness constancy, such as direct visual odometry, dense flow and stereo matching, then see a global change they must explain; Zhang, Forster and Scaramuzza (2017) note that changing the exposure time breaks this assumption for many visual odometry algorithms. Remedies include modelling the change as an affine brightness transformation per frame, which Zhang et al. describe as a widely used technique and compare with compensation through the camera’s photometric response; recording the exposure time of every frame and inverting a calibrated response, as the TUM monoVO dataset makes possible by providing per-frame exposure times together with the camera response and vignetting (Engel, Usenko and Cremers, 2016); estimating the exposure times, response and vignetting online, as Bergmann, Wang and Cremers (2018) do for auto-exposure video; and, simplest, locking the exposure when the lighting allows it. Stereo rigs add a second problem: two cameras with independent auto-exposure differ from each other, as in the EuRoC MAV dataset.

Examples

Shutter time against gain on a moving scene

The example renders three bright squares on a dark background moving right at 1 pixel per millisecond and captures them at exposure times from 1/8 ms to 16 ms, a range of seven stops. For each exposure time the gain is chosen so that the squares reach 200 of 255 digital numbers, giving every capture the same brightness. Motion blur is simulated by averaging the scene over sub-frames spread across the exposure, and noise by drawing Poisson shot noise for the electrons collected plus 2 electrons of Gaussian read noise. The task is corner localization: Harris corners refined to sub-pixel precision with scikit-image, matched to the twelve true corner positions at mid-exposure. The table lists the gain relative to the 16 ms capture, and reports the fraction of corners found within 4 pixels, the number of false corners and the mean error of the found corners, averaged over 20 noise draws, and two control columns: the error with the same noise on a static scene, and with the same motion but no noise.

import numpy as np
from skimage.feature import corner_harris, corner_peaks, corner_subpix

H, W, S = 80, 160, 4                  # image size; sub-samples per pixel side
SQUARES = [(20, 30), (20, 90), (46, 60)]   # top-left corners (row, col)
SIDE, V = 16, 1.0                     # square side (px); speed (px per ms)
RATE, READ = 40.0, 2.0                # electrons per ms at radiance 1; read noise

def render(dx):
    """Radiance: 0.1 background, 0.9 squares, squares shifted right by dx px."""
    y, x = (np.mgrid[0:H * S, 0:W * S] + 0.5) / S
    img = np.full((H * S, W * S), 0.1)
    for r, c in SQUARES:
        img[(y >= r) & (y < r + SIDE) & (x >= c + dx) & (x < c + dx + SIDE)] = 0.9
    return img.reshape(H, S, W, S).mean(axis=(1, 3))   # pixel integration

def capture(t, rng, v=V, noise=True):
    """Expose for t ms while the squares move; gain gives equal brightness."""
    n = max(4, int(np.ceil(v * t * 4)))              # sub-frames over the blur
    shifts = ((np.arange(n) + 0.5) / n - 0.5) * v * t  # centred on mid-exposure
    mean_e = np.mean([render(s) for s in shifts], axis=0) * RATE * t
    e = rng.poisson(mean_e) + rng.normal(0, READ, (H, W)) if noise else mean_e
    gain = 200.0 / (0.9 * RATE * t)                  # squares map to 200 DN
    return np.clip(np.round(e * gain), 0, 255)       # 8-bit output

# Ground truth: corners of each square at mid-exposure (pixel centres at k + 0.5)
truth = np.array([(r + dr - 0.5, c + dc - 0.5) for r, c in SQUARES
                  for dr in (0, SIDE) for dc in (0, SIDE)])

def score(img):
    """Harris corners refined to sub-pixel; match to truth within 4 px."""
    im = img / 255.0
    peaks = corner_peaks(corner_harris(im, sigma=1.5), min_distance=5,
                         threshold_rel=0.1)
    sub = corner_subpix(im, peaks, window_size=9)
    pts = np.where(np.isnan(sub), peaks, sub)
    d = np.linalg.norm(truth[:, None] - pts[None], axis=2)
    hit = d.min(axis=1) <= 4.0
    return hit.mean(), (d.min(axis=0) > 4.0).sum(), d.min(axis=1)[hit].mean()

print(f"static, noiseless: error {score(capture(1, None, v=0, noise=False))[2]:.2f} px")
print(f"{'t (ms)':>7}{'gain':>6}{'e-':>7}{'blur':>6}{'found':>7}{'false':>7}"
      f"{'error':>7}{'noise only':>12}{'blur only':>11}")
for t in [0.125, 0.25, 0.5, 1, 2, 4, 8, 16]:
    def mean_over_seeds(**kw):                       # 20 noise draws each
        return np.nanmean([score(capture(t, np.random.default_rng(seed), **kw))
                           for seed in range(20)], axis=0)
    found, false, err = mean_over_seeds()
    err_noise = mean_over_seeds(v=0)[2]              # static scene, same noise
    err_blur = score(capture(t, None, noise=False))[2]   # moving, noiseless
    print(f"{t:7.3f}{16 / t:6.0f}{0.9 * RATE * t:7.1f}{V * t:6.1f}{found:7.2f}"
          f"{false:7.1f}{err:7.2f}{err_noise:12.2f}{err_blur:11.2f}")

Output (NumPy 2.3.5, scikit-image 0.25.2):

static, noiseless: error 0.03 px
 t (ms)  gain     e-  blur  found  false  error  noise only  blur only
  0.125   128    4.5   0.1   0.57   45.5   1.94        1.94       0.03
  0.250    64    9.0   0.2   0.93    1.1   1.67        1.67       0.03
  0.500    32   18.0   0.5   1.00    0.1   1.41        1.36       0.04
  1.000    16   36.0   1.0   1.00    0.0   0.94        0.69       0.10
  2.000     8   72.0   2.0   1.00    0.0   0.66        0.25       0.16
  4.000     4  144.0   4.0   1.00    0.0   0.72        0.13       0.15
  8.000     2  288.0   8.0   1.00    0.0   0.83        0.09       0.42
 16.000     1  576.0  16.0   0.47    4.5   3.14        0.06       3.99

Every row has the same brightness, yet the corner error varies by a factor of about five and the false corners from none to dozens. On a still, noiseless image the detector is accurate to a few hundredths of a pixel, so the errors come from exposure. At the short end the squares collect only a handful of electrons; the gain of 128 makes the image as bright as the others but leaves the shot noise as large relative to the signal, and the noise produces dozens of false corners and misses almost half the true ones. The “noise only” column matches the full error there, confirming that blur plays no part. At the long end the corners are smeared over 16 pixels, wider than the matching radius allows, and more than half of them are lost; the “blur only” column shows this is blur, not noise. The best setting lies in between, near 2 ms here, where blur is a couple of pixels and each square collects tens of electrons per pixel.

In the middle rows the combined error is larger than either control column alone. Blur spreads each corner’s edges over several pixels and lowers their gradient, so the same noise moves the estimated corner further: blur and noise interact rather than simply adding. The optimum therefore depends on the speed, the light and the detector, which is why it is measured for a task rather than read off a rule.

An auto-exposure loop and the metering assumption

The second example simulates the controller from the auto-exposure section on a linear 8-bit camera viewing a rendered scene (a reflectance ramp with a white patch, a black patch and a grey card of reflectance 0.18). The target is the value that card would have at correct exposure, where correct means that a perfectly white surface just reaches 255. At frame 10 the light rises by a factor of 8 (three stops), as when a vehicle leaves a tunnel. The loop runs with and without a one-frame delay at several values of $k$. A second part lets the loop settle on two scenes that are far from average, a snowfield and a dark background, both containing the same grey card, metering either the whole frame or a region of interest on the card.

import numpy as np

H, W = 60, 80
x = np.mgrid[0:H, 0:W][1]
CARD = np.s_[22:38, 50:66]                       # a grey card, reflectance 0.18
ALL = np.s_[:, :]
TARGET = 0.18 * 255                              # mid-grey target, in DN

# Rendered test scene: reflectance ramp with a white patch, a black patch, a card
scene = 0.05 + 0.85 * x / (W - 1)
scene[10:25, 10:25], scene[35:50, 10:25], scene[CARD] = 0.9, 0.03, 0.18

def capture(t, light, refl):
    """Linear 8-bit camera; t = 1 maps reflectance 1 under light 1 to 255."""
    return np.clip(np.round(255 * refl * light * t), 0, 255)

def run(k, light, refl, region=ALL, delay=1, t0=1.0):
    """Proportional control in stops; a request reaches the sensor `delay` frames later."""
    t = [t0] * (delay + 1)                       # t[n]: exposure used for frame n
    means = []
    for n, L in enumerate(light):
        m = capture(t[n], L, refl)[region].mean()     # meter the region
        means.append(m)
        step = k * np.log2(TARGET / max(m, 0.5))      # error in stops, times k
        t.append(np.clip(t[-1] * 2 ** step, 1e-3, 1e3))
    return np.array(means), t[len(light) - 1]

# 1. Convergence after the light rises 3 stops at frame 10
light = np.r_[np.full(10, 1.0), np.full(30, 8.0)]
t0 = TARGET / capture(1.0, 1.0, scene).mean()   # settled before the step
for k, delay in [(1.0, 0), (0.25, 1), (0.5, 1), (1.0, 1)]:
    m, _ = run(k, light, scene, delay=delay, t0=t0)
    err = np.log2(m[10:] / TARGET)                     # stops from the target
    ok = [np.all(np.abs(err[i:]) < 0.1) for i in range(len(err))]
    settle = str(ok.index(True)) if any(ok) else "never"
    print(f"k={k:4.2f} delay={delay}: settles after {settle:>5} frames, "
          f"undershoot {max(0, -err.min()):.2f} stops; mean DN, frames 9-19:",
          " ".join(f"{v:3.0f}" for v in m[9:20]))

# 2. Metering: average of the frame versus a region of interest on the card
snow = np.full((H, W), 0.9); snow[CARD] = 0.18; snow[40:55, 5:20] = 0.03
dark = np.full((H, W), 0.03); dark[CARD] = 0.18; dark[5:15, 5:15] = 0.9
print(f"{'scene':<6}{'metering':<10}{'stops vs t=1':>13}{'card':>7}{'white':>7}{'clipped':>9}")
for name, refl in [("snow", snow), ("dark", dark)]:
    for mode, region in [("average", ALL), ("card ROI", CARD)]:
        _, t = run(0.5, np.ones(40), refl, region)    # let the loop settle
        img = capture(t, 1.0, refl)
        print(f"{name:<6}{mode:<10}{np.log2(t):+13.2f}{img[CARD].mean():7.0f}"
              f"{img[refl == 0.9].mean():7.0f}{(img == 255).mean():9.1%}")

Output (NumPy 2.3.5):

k=1.00 delay=0: settles after     2 frames, undershoot 0.00 stops; mean DN, frames 9-19:  46 209  81  46  46  46  46  46  46  46  46
k=0.25 delay=1: settles after    10 frames, undershoot 0.00 stops; mean DN, frames 9-19:  46 209 209 189 160 121  88  69  59  53  50
k=0.50 delay=1: settles after    11 frames, undershoot 0.49 stops; mean DN, frames 9-19:  46 209 209 160  81  43  33  34  40  47  50
k=1.00 delay=1: settles after never frames, undershoot 2.18 stops; mean DN, frames 9-19:  46 209 209  81  18  10  26 119 176  81  21
scene metering   stops vs t=1   card  white  clipped
snow  average           -2.19     10     50     0.0%
snow  card ROI          +0.00     46    230     0.0%
dark  average           +2.11    198    255     2.1%
dark  card ROI          +0.00     46    230     0.0%

Without delay, a full correction ($k = 1$) should settle in one frame, but it needs two: the first bright frame is heavily clipped, its mean reads 209 instead of the $8 \times 46 \approx 367$ an unclipped sensor would give, so the first step is too small. With a one-frame delay the three gains behave as the characteristic equation predicts. At $k = 0.25$, the boundary case with a repeated real root, the brightness falls back without overshoot; at $k = 0.5$ it overshoots by half a stop before settling; at $k = 1$ it swings by several stops either side of the target and never settles, which a viewer would see as hunting. Every frame between the step and settling shows the same static scene at a different brightness, which is the violation of brightness constancy a tracker downstream must absorb.

The metering part shows the mid-grey assumption failing in both directions. Averaged over the frame, the snow scene is driven down by over two stops: the snow comes out at a mid-grey 50 instead of 230, and the card sinks into the bottom few percent of the range. The dark scene is driven up by about two stops, so the card is far too bright and the white patch clips. Metering the card alone gives the correct exposure in both scenes, because the region now has the average the target assumes.

Beyond a Single Exposure

When the part of a scene that matters spans more stops than the sensor’s dynamic range, no single setting serves it: a tunnel exit, a window in a dark room or a welding arc will clip or drown in noise whatever the controller does. High dynamic range imaging addresses this by capturing several exposures, bracketed in stops, recovering the camera’s response function and merging them (Szeliski, 2022, Sections 10.1.1 and 10.2). Some sensors extend the range inside one capture; the GenICam naming convention, for example, defines features for multi-slope exposure, which gives one image with a piecewise-linear response (SFNC 2.8, Section 5.8). Tone mapping then compresses the merged range for display. Within a single frame, exposure decides which part of the range is kept.

Common Misconceptions

• “Raising ISO makes the sensor more sensitive.” At a fixed exposure time and aperture a higher ISO collects the same light, so it gives a brighter image with less room before clipping and, apart from any fall in read noise referred to the pixel, the same noise relative to signal.
• “Two settings that give the same brightness give the same image.” They give the same mean brightness only. In the first example, eight settings with equal brightness differ by a factor of almost five in corner error, and lose different corners for different reasons.
• “Correct exposure means a mid-grey histogram.” That is what an average meter enforces, and it is wrong for any scene whose average is not mid-grey. For a vision task, the right exposure keeps the object of interest inside the sensor’s range with enough signal.
• “Auto-exposure is a measurement of the scene.” It is a feedback loop with latency; during convergence and oscillation, consecutive frames record the same scene at different brightness.
• “For vision, the shortest exposure is always best.” It minimizes blur, but at a fixed light level it also minimizes the photons collected. The first example’s optimum lies in the middle of the range.

Where It Is Used

Exposure is configured, explicitly or by default, in every camera-based system. Machine-vision installations can fix exposure under controlled lighting, so that a part looks the same in every frame, and use metering regions or Once-style automatic exposure followed by a fixed setting when the light can drift. Robots and vehicles, which move between lighting conditions, run continuous auto-exposure and pay for it in brightness changes; visual odometry and SLAM systems either compensate photometrically, as above, or rely on keypoint detectors and descriptors that are robust or invariant to monotonic brightness changes, as Engel, Usenko and Cremers (2016) note, and on feature tracking that tolerates them. Datasets for photometric methods record per-frame exposure times so that algorithms can undo exposure changes (Engel, Usenko and Cremers, 2016).

Exposure also shapes what learned models see: training images carry the camera’s choices, including clipped skies and noisy shadows. Image denoising recovers part of what a short exposure loses to noise, and deblurring part of what a long one loses to motion, so processing can shift the exposure trade-off but not remove it.