Image Histograms & Statistics

"I have never actually looked at the image. I just count who showed up and read the room."

A Compulsively Counting Histogram Bin

In Section 2.1 we adjusted brightness, contrast, and gamma, but a human had to choose the parameters, and our one automated method (percentile stretching) quietly relied on the distribution of intensities. This section studies that distribution properly. The histogram is the diagnostic instrument of image processing: it is what your camera shows on its exposure display, what radiologists' workstations compute behind every window-level control, and what the next two sections will mine for automatic enhancement and segmentation.

1. What a Histogram Is Basic

For a grayscale image $f$ with $L$ intensity levels (for uint8, $L = 256$), the histogram is the function

$$h(k) = \#\{(x, y) : f(x, y) = k\}, \qquad k = 0, 1, \ldots, L-1$$

that counts how many pixels take each value. Dividing by the total pixel count $N$ gives the normalized histogram $p(k) = h(k)/N$, which is exactly the empirical probability distribution of intensity: the probability that a uniformly random pixel of this image has value $k$. The two forms carry identical information; the normalized one lets you compare images of different sizes and plug into probability formulas, which we will do repeatedly.

What the histogram preserves, and what it discards, are equally important. It preserves the full tonal population: how much shadow, how much midtone, how much highlight. It discards all spatial arrangement. Shuffle the pixels of an image into random positions and its histogram does not change by a single count, even though the image becomes unrecognizable noise. Figure 2.2.1 shows the three histogram silhouettes you will learn to recognize instantly: the left-piled histogram of underexposure, the narrow central hump of low contrast, and the broad, well-spread distribution of a properly exposed image.

2. Computing Histograms Fast Basic

Conceptually a histogram is a loop: for every pixel, increment a counter. In Python, you should never write that loop. The code below shows the three idiomatic ways to compute the same 256-bin histogram, with their typical relative speeds on a 12-megapixel grayscale image.

import numpy as np
import cv2

gray = cv2.imread("scene.jpg", cv2.IMREAD_GRAYSCALE)   # uint8, shape (H, W)

# 1. np.histogram: general-purpose, any bin edges, any dtype
h1, edges = np.histogram(gray, bins=256, range=(0, 256))

# 2. np.bincount: fastest pure-NumPy route for uint8 (bins ARE the values)
h2 = np.bincount(gray.ravel(), minlength=256)

# 3. cv2.calcHist: OpenCV's engine; supports masks and multi-channel
h3 = cv2.calcHist([gray], channels=[0], mask=None,
                  histSize=[256], ranges=[0, 256]).ravel()

assert (h1 == h2).all() and (h2 == h3.astype(np.int64)).all()
print(h2[:4])   # e.g. [ 1208  1532  1719  2004 ]  counts for intensities 0..3

Each route has its niche. np.histogram handles arbitrary bin edges and float images (useful after the float conversions of Section 2.1). np.bincount wins on speed for uint8 because each pixel value is its own bin index. cv2.calcHist earns its keep when you need a mask (histogram of a region only) or joint multi-channel histograms, which we use below. One practical warning from Chapter 0 applies here: cv2.calcHist returns a float32 column array of shape (256, 1), so .ravel() it before comparing with NumPy results.

hist = cv2.calcHist([img], [0], region_mask, [256], [0, 256])

3. Statistics From the Histogram Intermediate

Because $p(k)$ is a probability distribution, every statistic you know from probability applies directly. The mean intensity and variance are

$$\mu = \sum_{k=0}^{L-1} k\, p(k), \qquad \sigma^2 = \sum_{k=0}^{L-1} (k - \mu)^2\, p(k)$$

and a useful single-number summary of tonal richness is the Shannon entropy,

$$H = -\sum_{k:\, p(k) > 0} p(k) \log_2 p(k)$$

measured in bits. Entropy is maximized (8 bits for uint8) by a perfectly uniform histogram and collapses toward 0 as the image approaches a single flat tone. A washed-out, low-contrast image might carry 4 to 5 bits; a rich, well-exposed photograph typically carries 7 or more. Entropy connects directly back to the quantization discussion of Chapter 1: it measures how much of the container's capacity the image actually uses, and it will reappear conceptually when histogram equalization tries to flatten $p(k)$ in Section 2.3.

import numpy as np

def exposure_report(gray):
    """Histogram-derived exposure diagnostics for a uint8 grayscale image."""
    h = np.bincount(gray.ravel(), minlength=256).astype(np.float64)
    p = h / h.sum()                                  # normalized histogram
    k = np.arange(256)

    mean = (k * p).sum()
    std  = np.sqrt(((k - mean) ** 2 * p).sum())
    nz   = p[p > 0]
    entropy = -(nz * np.log2(nz)).sum()

    cdf = p.cumsum()                                 # cumulative distribution
    p2, p98 = np.searchsorted(cdf, [0.02, 0.98])     # robust range endpoints

    return {
        "mean": round(mean, 1), "std": round(std, 1),
        "entropy_bits": round(entropy, 2),
        "p2": int(p2), "p98": int(p98),
        "clip_lo": round(p[0] * 100, 2),             # % of pixels at 0
        "clip_hi": round(p[255] * 100, 2),           # % of pixels at 255
    }

# Typical output on an underexposed frame:
# {'mean': 41.3, 'std': 28.7, 'entropy_bits': 5.91, 'p2': 4, 'p98': 122,
#  'clip_lo': 3.4, 'clip_hi': 0.0}

Functions like exposure_report are the bread and butter of production vision systems: they run in under a millisecond and answer "is this input even worth sending to the model?" The same statistics computed across an entire dataset, rather than one image, become the channel means and standard deviations used to normalize network inputs, a practice examined in Chapter 21.

4. Color and Two-Dimensional Histograms Intermediate

For color images, the simplest move is three independent histograms, one per channel. They diagnose color casts immediately: a tungsten-lit indoor shot shows its blue histogram huddled to the left of red and green. But per-channel histograms cannot represent the joint structure of color, since they would not distinguish an image of red and blue patches from an image of uniformly purple pixels. For that you need a joint histogram over two (or more) channels at once. A classic choice, using the HSV decomposition from Chapter 1, is the hue-saturation histogram, which describes the palette of an image while ignoring brightness.

import cv2

img = cv2.imread("beach.jpg")
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# Joint hue-saturation histogram: 30 hue bins x 32 saturation bins.
# Hue in OpenCV uint8 runs 0..179 (degrees / 2), saturation 0..255.
hs_hist = cv2.calcHist([hsv], channels=[0, 1], mask=None,
                       histSize=[30, 32], ranges=[0, 180, 0, 256])
hs_hist = cv2.normalize(hs_hist, None, alpha=1.0, beta=0.0,
                        norm_type=cv2.NORM_L1)        # sums to 1.0

print(hs_hist.shape)   # (30, 32): a palette fingerprint of the image

This 960-number palette fingerprint is a genuinely useful image descriptor: it powered the first generation of content-based image retrieval systems, and OpenCV's histogram backprojection uses it to find regions whose colors match a model, an idea that resurfaces in the mean-shift tracking of Part II. Coarse binning (30 by 32 rather than 180 by 256) is deliberate: fewer bins mean more samples per bin, which makes the estimated distribution less noisy and comparisons more stable.

5. Comparing Histograms Intermediate

Once images are distributions, "how similar are these two images?" becomes "how similar are these two distributions?", a question statistics has many answers for. Four are built into OpenCV: correlation, chi-square, intersection, and Bhattacharyya distance. Histogram intersection, $d(p, q) = \sum_k \min(p(k), q(k))$, has a particularly clean reading: the fraction of probability mass the two distributions share.

import cv2

def palette_similarity(img_a, img_b):
    """Compare two images by their hue-saturation distributions."""
    hists = []
    for im in (img_a, img_b):
        hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV)
        h = cv2.calcHist([hsv], [0, 1], None, [30, 32], [0, 180, 0, 256])
        cv2.normalize(h, h, 1.0, 0.0, cv2.NORM_L1)
        hists.append(h)
    return {
        "correlation":   cv2.compareHist(hists[0], hists[1], cv2.HISTCMP_CORREL),
        "intersection":  cv2.compareHist(hists[0], hists[1], cv2.HISTCMP_INTERSECT),
        "bhattacharyya": cv2.compareHist(hists[0], hists[1], cv2.HISTCMP_BHATTACHARYYA),
    }

# Two frames from the same video shot:
#   {'correlation': 0.97, 'intersection': 0.91, 'bhattacharyya': 0.11}
# A frame versus a different scene:
#   {'correlation': 0.23, 'intersection': 0.34, 'bhattacharyya': 0.62}

At microseconds per comparison, histogram matching like this still earns a place in modern systems as a prefilter: deduplicating crawled image datasets before expensive embedding models run, detecting shot boundaries in video, and sanity-checking that a camera's color rendition has not drifted between calibration runs. Its descendants are everywhere. The histogram-of-gradients idea extends this section's machinery from intensities to edge orientations and becomes the HOG descriptor of Chapter 16; and comparing distributions of deep features, rather than raw intensities, is precisely how FID scores generative models in Chapter 37.