Bit Depth

Bit depth is how many shades each pixel can name. Eight bits give 256 levels per channel, and too few levels turn smooth skies into visible stripes.

Why Does This Exist?

Pixels hold integers, and somebody must decide how many distinct integers exist. That decision is bit depth: $n$ bits per channel allow $2^n$ levels. It sets the file size per pixel, the smoothness of gradients, and how much editing headroom a photo carries before it falls apart.

Most images you meet are 8-bit: $256$ levels per channel, $16.8$ million colors in RGB. Cameras capture $10$ to $14$ bits, medical and scientific sensors more. The gap between capture depth and display depth is where banding, HDR formats and quantization bugs all live.

Think of It Like This

A staircase versus a ramp

A smooth ramp from the street to a door lets a ball roll evenly. Replace it with four giant steps and the ball thuds down in jumps, resting flat on each tread.

Bit depth is the step count. Eight bits build a staircase with $256$ treads, fine enough that eyes read it as a ramp. Two bits build four treads, and every smooth sky shows the thuds as flat stripes.

The analogy stops here: real banding also depends on the display and viewing conditions, so the same file stripes on one screen and looks smooth on another.

How It Actually Works

With $n$ bits per channel, channel values run $0$ to $2^n - 1$ in steps of one. Common stops: $1$ -bit is binary $\{0, 1\}$ , $8$ -bit is $0$ – $255$ ( $256$ levels), $10$ -bit is $0$ – $1023$ ( $1024$ levels), $16$ -bit is $0$ – $65535$ . Total data per pixel is $n \times C$ bits, so an 8-bit RGB pixel costs $24$ bits and a 16-bit grayscale pixel costs $16$ .

Quantizing maps a high-depth value to the nearest available level. Information dies at that step and no later processing recovers it, which is why pipelines edit in high depth and export in $8$ -bit last.

Worked example: two bits make four skies

At $2$ bits the only shades are $\{0, 85, 170, 255\}$ : four evenly spaced treads across the $0$ – $255$ range. A pixel measuring $124$ snaps to the nearest tread. Distances are $|124 - 85| = 39$ versus $|124 - 170| = 46$ , so it lands on $85$ : an error of $39$ levels, plainly visible. That rounding of neighbours onto shared treads is posterization, the striped-sky failure.

Code

1levels = [0, 85, 170, 255]  # every shade a 2-bit pixel can name2value = 124  # what the sensor measured3nearest = min(levels, key=lambda l: abs(l - value))4print(nearest, "instead of", value)5# -> 85 instead of 124

Watch Out For

uint8 arithmetic wraps instead of clipping

NumPy adds uint8 arrays modulo $256$ , so brightening $200$ by $100$ yields $44$ : a black hole where a highlight belonged. Cast to a wider integer or float before any brightness math, clip to the legal range, and only then cast back to the working depth.

Quantizing before augmenting bakes in stripes

Downconverting to $8$ -bit and then stretching contrast amplifies the tread gaps into hard bands. Keep capture depth (or float) through every enhancement step and quantize exactly once at export, dithering if the gradient must stay smooth.

The Quick Version

Bit depth $n$ gives $2^n$ levels per channel: 256 at 8 bits, 1024 at 10 bits, 65536 at 16 bits.
Most photos are 8-bit per channel; sensors capture 10 to 14 bits of editing headroom.
Too few levels posterize smooth gradients into flat visible bands.
At 2 bits our pixel measuring 124 snaps to 85, an error of 39 levels.
Do arithmetic in wide types and quantize once at export, never mid-pipeline.