3.3 Point operations🔗⧉

The very first thing anyone does to a photo is brighten it. You nudge one slider, every pixel gets a little lighter, and yet nothing about where things are has changed — a face is still a face, in the same place, just brighter. That edit, and a remarkable fraction of the edits photographers actually make, share a structure worth naming before we build anything more elaborate: each output pixel depends only on the value of the input pixel at the very same spot. This chapter is about that whole family — exposure, brightness, contrast, levels, freehand curves, saturation and vibrance, and the lookup tables that bake them in — what they can and cannot do, and the single question that decides whether each is done right or wrong: the numerical space it acts in.

3.3.1 Three kinds of operation🔗⧉

Before zooming in, it pays to sort every image operation into one of three families, according to what each output pixel is allowed to read (Figure 3.3.1). Recall that an image is a function over a 2-D domain — the grid of positions (x, y) — whose values live in a range, here color (we set this up in Image representation). The three families are precisely the three ways an operation can touch the domain and the range.

A point operation touches the range only. The output pixel depends solely on the input pixel's value at the same location, and one and the same rule is used everywhere:

There is a single input-to-output curve f, applied identically at every pixel. In words: read a pixel's value, find where that value lands on the curve, write the answer back — no neighbours consulted, nothing moved. Brightness, contrast, exposure, gamma, and lookup tables are all point operations, and we begin here because they are the simplest to reason about and the cheapest to run.

A domain operation is the mirror image: it relocates pixels without changing their colors, so the output pixel is copied from a different input location, $I_\text{out}(x, y) = I_\text{in}(x', y')$ for some remapped (x', y'). Resizing, rotating, warping, and lens-distortion correction live here; they are the subject of the resampling chapter.

A neighborhood operation sits in between: the output pixel is computed from a whole window of input pixels around the same spot. Blur averages a pixel with its neighbours; sharpening, edge detection, and the bilateral filter all read a neighbourhood. Those get their own chapter on convolution.

Everything below stays in the left column. One convenience keeps the discussion clean: a point operation acts on a single number, so we develop it on a grayscale value L and write the curve $L_\text{out} = f(L_\text{in})$; for a color image the same curve is applied independently to each of the R, G, B channels — unless we say otherwise. (Saturation, near the end, is the one genuine exception that couples the channels.)

3.3.2 The point-operation curve🔗⧉

Since a point operation is just one curve f applied to every pixel, the curve is the operation, and photo editors hand it to you directly: the curves tool plots input value across the horizontal axis, output value up the vertical, and lets you bend the line by hand. The "do nothing" case — leave every value untouched — is the 45° diagonal. Everything in this chapter is some way of bending that diagonal: lift it to brighten, steepen it to add contrast, pin its ends to set black and white points, or just drag it freehand.

Controlling that mapping is not a digital invention. Photography has always been the craft of deciding how scene radiance becomes printed tone — film stock, exposure, development, paper grade, and the enlarger all shape it — and the digital tone curve is merely the most direct handle yet on the same old problem. There is, though, one question we must answer before we bend anything, and it runs through the whole chapter: in which numerical space does the curve act?

The same image can be stored as linear-light values (proportional to the physical radiance the sensor measured), as gamma/sRGB-encoded values (the perceptually spaced numbers a PNG actually holds), or as log values (handy when the range is enormous). We met these encodings in Image representation; here they stop being a storage detail and start changing the result. Apply the very same arithmetic in linear light versus in sRGB and you get visibly different pixels — so every operation below carries a note about the space it belongs in.

3.3.3 Exposure: a multiply in linear light🔗⧉

Exposure is the workhorse, and it has a clean physical meaning. On the camera, changing the exposure — a longer shutter, a wider aperture, a higher ISO — multiplies the light recorded at every pixel by one common factor (we develop the controls themselves in the sensor chapter). Double the exposure and you double the radiance: a purely multiplicative effect, whose natural unit is the photographic stop, one stop being a factor of two. An adjustment of s stops therefore multiplies the linear-light value by $2^s$:

Plotted in display space the +1-stop curve bows upward above the diagonal, lifting the shadows generously and flattening as it nears the top; whatever it pushes past 1 is clipped to white and gone for good (Figure 3.3.3). That is the honest cost of brightening — blown highlights do not come back.

The "in linear light" qualifier is not pedantry — it is the line between a correct exposure change and a wrong one. The library makes the distinction concrete: imageops.exposure(img, stops) decodes to linear light, multiplies, then re-encodes; ask it for the naive version instead and it multiplies the gamma-encoded numbers directly, which is exactly what happens when you forget to linearize. The two part ways sharply, and the next figure is devoted to showing how.

3.3.4 Brightness vs. exposure🔗⧉

It is tempting to think a "brightness" slider does the same job, but it does something subtly worse. Brightness is an additive offset: it adds the same constant b to every value,

which slides the whole transfer line straight up by b (a parallel shift, intercept b). The trouble is what it does to black. Exposure keeps black at black — multiply zero by anything and it stays zero — but brightness lifts true black off the floor to b, so the darkest tones turn into a flat, milky grey and the shadows look fogged (Figure 3.3.5). For that reason we generally recommend against brightness and for exposure: exposure is the more radiometric control, faithful to how light actually scales, whereas brightness survives mostly as a legacy slider or a quick-and-dirty shadow lift.

3.3.5 Contrast: steepen about a pivot🔗⧉

Where exposure moves all the tones the same way, contrast spreads them apart or pulls them together. The idea is to pick a pivot value — a mid-grey that stays put — and push every other value away from it (more contrast) or toward it (less). Values above the pivot get brighter, values below get darker, and the pivot itself never moves. As a curve, that is a straight line through the pivot whose slope is the contrast gain g:

where p is the pivot. Read it as: measure how far a value sits from the pivot, scale that distance by the gain, add it back. A gain above 1 steepens the line and raises contrast; a gain below 1 flattens it and lowers contrast. The steeper the line, the sooner it slams into the floor at 0 and the ceiling at 1 — so strong contrast clips both shadows and highlights (Figure 3.3.6).

And here the recurring question bites hardest: in which space do we steepen? Unlike exposure, contrast has no single physically correct answer — it is a stylistic operation, and the choice of space changes its character outright (Figure 3.3.7). Steepen in sRGB/gamma (the default in most editors, and the library's default for imageops.contrast) and the pivot sits at a perceptual mid-grey, so the effect roughly tracks how the eye judges contrast. Steepen in linear light and the gain acts on physical radiance, which weights the highlights very differently and tends to look harsher, crushing the shadows. Steepen in log (a density-like space) and the operation becomes a uniform stretch in ratios, the gentlest on a wide range. None is "wrong" — they are three legitimate looks, and a good editor lets you choose. We flag the spread here and defer the full radiometric-versus-perceptual argument to the tone-mapping chapter, where it shapes the design of high dynamic range (HDR) operators.

3.3.6 Black point, white point, and levels🔗⧉

Most photographs do not use the full tonal range: the darkest pixel might sit at a murky 0.08, the brightest at a dull 0.9, leaving the image flat and hazy. The levels tool fixes this by stretching the used range back out to fill [0, 1]. You set a black point — the input value that should map to 0 — and a white point — the input value that should map to 1 — and everything between is stretched linearly across the full range; anything below the black point clips to black, anything above the white point clips to white. A third control, a mid-grey gamma slider, bends the curve between the two anchors to lift or lower the midtones without disturbing the endpoints.

Levels is the first edit on almost every image, and it is really a piecewise version of the curves we have already met — clip-and-stretch at the ends, a gamma bow in the middle (Figure 3.3.8). The natural way to set it is by eye on the histogram: pull the black point up to where the dark tones actually start, pull the white point down to where the bright tones end, and nudge the gamma until the midtones sit right. That makes the histogram — which earns its own short chapter next — the levels tool's constant companion.

3.3.7 The general tone curve🔗⧉

Exposure, contrast, and levels are all constrained shapes — a fan, a straight steepen, a clipped stretch. The most general point operation simply lets you draw the curve freehand: the tone curve tool gives you a handful of control points to drag wherever you please, and the editor threads a smooth interpolating curve through them (Figure 3.3.9). To keep the result sane the curve is fit with a spline that is held monotone — never decreasing — so a brighter input can never produce a darker output. (A non-monotone tone curve would invert tones locally, which looks bizarre.) Catmull–Rom and monotone-cubic splines are the usual choices, the latter when the no-inversion guarantee must be exact.

A freehand tone curve subsumes everything earlier in the chapter — you could draw the exposure bow, the contrast steepen, or the levels stretch by hand — which is why it is the photographer's most general tonal tool. The tone-mapping chapter pushes the idea to its physical conclusion with principled, automatically chosen curves (the Reinhard operator $L/(1+L)$ and relatives) for compressing high-dynamic-range scenes; here we simply note that the general curve is the container they all fit into.

3.3.8 Basic color enhancement: saturation and vibrance🔗⧉

So far every operation has run on one channel at a time. Saturation is different: it is about color, the relationship between channels, so it cannot be a per-channel curve. Raising saturation pushes each pixel's color further from grey — reds redder, blues bluer — while leaving its overall lightness alone; lowering it pulls colors toward grey, with full desaturation giving a black-and-white image. The clean way to think about it is to split each pixel into a luminance (how bright) and a chrominance (which color, how pure), scale the chrominance, and recombine — the luminance/chrominance split we lean on again and again throughout the book.

That split is literally one line of code. Let $Y$ be the pixel's luminance, broadcast back to all three channels; then its chrominance is just $\text{RGB} - Y$ (what is left after the grey is removed), and saturation scales it:

With $s = 1$ the image is unchanged, $s = 0$ collapses every pixel onto its own grey (black-and-white), and $s > 1$ pushes colors away from grey. Written the other way, $\text{RGB}' = (1-s)\,Y + s\,\text{RGB}$ — a straight-line blend between the grayscale version and the original, extrapolated past it once $s > 1$. Because this is a color edit rather than a tone edit, it is applied to display-encoded (gamma/sRGB) values, the space the editor's sliders live in; doing it well means a perceptually uniform space, which we come to below.

Vibrance is a gentler cousin: it boosts the saturation of muted colors more than already-vivid ones, and typically spares skin tones, so portraits do not turn garish (Figure 3.3.11). It is the same formula, but with the constant $s$ replaced by a per-pixel gain that is large where a pixel is dull and fades to nothing where it is already colorful (and near skin hues):

Here $\text{sat}$ is the pixel's current saturation — for instance the hue-saturation-value (HSV) quantity $S = (\max - \min)/\max$, or the chroma magnitude divided by luminance — $v$ is the vibrance amount, and $w_\text{skin}(\text{hue})$ is a hue weight near $0$ on skin and orange tones and $1$ elsewhere (set it to $1$ everywhere for a skin-agnostic version). Because the gain carries the $(1 - \text{sat})$ factor, a flat grey-blue sky gets the full boost while an already-vivid flower, or a face, barely moves. Photographers reach for a touch of vibrance as a finishing move — cameras tend to render colors a little flat — but it is easy to overdo.

One honest caveat: "how far from grey" and "leave lightness alone" both depend on the color space you measure them in, and doing this well means scaling chrominance in a perceptually uniform space rather than naively in RGB. That choice of space — and why skin needs protecting at all — is genuinely the subject of the color part, so it is what we defer to Color technology; the mechanics are the two equations above. Both saturation and vibrance are color operations, not tone operations.

3.3.9 Lookup tables🔗⧉

Once a point operation is any fixed curve f, there is a cheap trick that applies to all of them at once. If pixel values come from a small finite set — the 256 levels of an 8-bit channel, say — there is no need to evaluate f at every pixel. Evaluate it once per possible value, store the 256 answers in a small table, and then for each pixel just look up its result. This precomputed table is a look-up table (LUT), and it turns an arbitrarily complicated tone curve into a single array index per pixel — the same cost whether f is a gamma curve, an S-curve, or a hand-drawn spline.

A 1-D LUT is exactly this: three independent per-channel curves, into which exposure, contrast, levels, and gamma all collapse. It cannot express a cross-channel effect, because each output channel depends only on its own input channel. A 3-D LUT lifts that limit: it maps a whole (R, G, B) triple at once, so it can do the things a per-channel curve cannot — white balance, saturation, a full color grade. The price is size: a dense 3-D table would be enormous, so it is sampled on a coarse grid (the .cube files of video carry a few dozen entries per axis) and interpolated between samples. LUTs are everywhere once you look: the gamma encode/decode step is a 1-D LUT, a creative "film look" ships as a 3-D LUT, and the same trick doubles as a speed optimization — precompute any expensive per-value function once, then index it (the basis of fast fixed-point and 8-bit pipelines).

3.3.10 Video color grading🔗⧉

Tone and color tools evolved twice — once for stills and once for motion pictures — and the two vocabularies never fully merged. Color grading is the motion-picture craft, and it is worth meeting on its own terms because it is a separate discipline from the stills/radiometric editing the rest of this chapter describes: less concerned with physical radiance, far more concerned with the look of a film, and equipped with its own tools and idioms.

The colorist's primary controls are the lift / gamma / gain wheels. Rather than a single exposure or contrast slider, these split the tonal range into three overlapping bands — lift for the shadows, gamma for the midtones, gain for the highlights — and each wheel carries a color offset as well as a level, so you can, say, cool the shadows and warm the highlights independently. Corrections come in two layers: primary corrections act on the whole frame (overall balance and exposure), while secondary corrections are qualified — restricted to a range of hue or luma, or to a tracked mask — so you can grade just the sky, or one actor's shirt, without touching the rest.

The pipeline underneath is built for range and consistency. Footage is usually captured in a camera log encoding — Sony's S-Log, or Log-C from ARRI (the cine-camera maker) — which packs a wide dynamic range into the file the way log encoding always does (a multiplicative range becomes an additive one, the recurring lesson). Grading then happens inside a color-management framework, most prominently the Academy Color Encoding System (ACES), which defines common working and interchange spaces so that material from different cameras grades and intercuts predictably. The finished look is then frozen and shipped as a 3-D LUT — the .cube files from the lookup-tables section above — applied per frame, which is precisely why 3-D LUTs matter here: they are the delivery format for a grade.

The signature example is the teal-and-orange look. Skin tones are pushed toward warm orange; everything else is pulled toward the complementary teal. Because orange and teal sit opposite each other on the color wheel, the result is a built-in complementary contrast that makes people pop off the background (Figure 3.3.12). The look was popularized by the digital grade of O Brother, Where Art Thou? (2000) — among the first features finished entirely as a digital intermediate (the Coen brothers, cinematographer Roger Deakins) — and it has been imitated to the point of cliché ever since.

The stills world has a close cousin: Lightroom's hue-saturation-lightness (HSL) / color-mixer and color-grading panels do much the same hue-selective work a colorist does with secondaries. We mostly speak the stills/radiometric dialect in this book, but the operations underneath are the same point operations seen through a different craft. The grading toolkit ties back to #Lookup tables (3-D LUTs as the delivery format), to Color technology (color management, log encoding, ACES), and forward to tone mapping (the dynamic-range side of the same problem).

3.3.11 Local point operations🔗⧉

One honest loose end. We defined a point operation as depending only on a pixel's value, the same rule everywhere — yet editors constantly let you apply these very tools locally, through a selection or a mask: brighten only the sky, add contrast only to the face. Strictly, that is no longer a point operation, because the result now depends on where the pixel is and not just its value — it is the digital descendant of the darkroom's dodging and burning. Selections come in many flavours — by value or color (the magic wand), by a painted brush, by a gradient ramp (linear or radial), edge-aware (snapping to object boundaries), and increasingly by AI semantic segmentation (segment-anything-style). The edge-aware kind hints at a theme we will keep meeting: an edge-preserving selection treats two pixels as belonging together when their colors are similar — an affinity — which is the very idea that drives the bilateral filter. We flag selections here so the boundary of "point operation" is clear; the machinery is the bridge to local tone mapping and the edge-preserving filtering of later chapters.

The connection to the darkroom is exact (Figure 3.3.13). Wherever the mask is bright, the adjustment acts; where it is dark, the pixel is untouched. Run a local exposure through a mask and you have reinvented dodging (locally brightening — holding light back in the printing easel) and burning (locally darkening — giving extra exposure): the only difference is that the mask is now a soft digital matte instead of a piece of cardboard waved over the paper. A radial gradient lifts a face out of the shadows; a linear gradient is the graduated-ND filter that holds back a bright sky; a painted brush burns down one distracting highlight. Everything earlier in the chapter — exposure, contrast, the tone curve — becomes a local tool the moment it is gated by a mask.