Opening, Closing & Morphological Gradients

"I went in for a small procedure: they eroded my speckle, then dilated me right back to size. The surgeon says a second visit would change nothing. Apparently I am now idempotent."

A Recently Opened Binary Mask

The previous section closed on a deliberate loose end: erosion and dilation are not inverses, and information destroyed by one cannot be recovered by the other. This section weaponizes that asymmetry. Erode a mask and every speck smaller than the structuring element is gone forever; dilate the result and the surviving objects regrow to their original size, minus the casualties. Run the pair in the opposite order and pinholes vanish instead of specks. These two compositions, with their differences and grayscale variants, form the standard toolkit applied to virtually every thresholded image before anyone dares count or measure anything, including the masks produced by the segmentation networks of Chapter 24.

1. Opening: Delete the Small, Restore the Rest Beginner

The opening of $A$ by structuring element $B$ is erosion followed by dilation with the same SE:

$$ A \circ B \;=\; (A \ominus B) \oplus B. $$

There is an equivalent characterization that explains the behavior far better than the formula: the opening is the union of all placements of $B$ that fit entirely inside $A$. Imagine painting the inside of every object using $B$ as the brush, never letting the brush cross the boundary. Whatever the brush can reach survives; whatever it cannot (specks smaller than the brush, hairline protrusions, thin bridges) is erased. Surviving objects keep their size and roughly their shape, with convex corners gently rounded to the brush's curvature. Opening also never adds a single pixel: $A \circ B \subseteq A$, a property called anti-extensivity.

2. Closing: Fill the Small, Preserve the Rest Beginner

The closing runs the composition in the opposite order:

$$ A \bullet B \;=\; (A \oplus B) \ominus B. $$

By the duality law of Section 6.2, closing the foreground is exactly opening the background: $A \bullet B = (A^c \circ \hat{B})^c$. Every fact about opening therefore has a closing mirror. Closing fills pinholes and narrow gulfs smaller than the SE, bridges gaps thinner than the SE, and never removes a pixel ($A \subseteq A \bullet B$, extensivity). The brush picture works here too, painted from outside: closing keeps every point the brush cannot reach when rolled around the exterior, so small interior voids that the brush cannot enter get sealed.

Both compositions share a third property that no amount of repeated blurring from Chapter 3 can claim: idempotence. Opening an opened image changes nothing, $(A \circ B) \circ B = A \circ B$, and likewise for closing. The operator converges in one application; "more cleanup" requires a bigger SE, not another pass. Figure 6.3.1 shows the canonical cleanup pipeline that puts both to work.

The pipeline of Figure 6.3.1 is six lines of code. The demonstration below builds a controllable mess (one true object, salt specks, glare holes) so the cleanup can be verified by counting rather than by squinting:

import cv2
import numpy as np

rng = np.random.default_rng(7)
mask = np.zeros((400, 400), np.uint8)
cv2.circle(mask, (200, 200), 120, 255, -1)            # the real object
for x, y in rng.integers(0, 400, (60, 2)):            # 60 salt specks
    cv2.circle(mask, (int(x), int(y)), int(rng.integers(1, 3)), 255, -1)
for x, y in rng.integers(120, 280, (25, 2)):          # 25 glare pinholes
    cv2.circle(mask, (int(x), int(y)), int(rng.integers(1, 4)), 0, -1)

se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
opened  = cv2.morphologyEx(mask,   cv2.MORPH_OPEN,  se)
cleaned = cv2.morphologyEx(opened, cv2.MORPH_CLOSE, se)

for name, m in [("raw", mask), ("opened", opened), ("cleaned", cleaned)]:
    n, _ = cv2.connectedComponents(m)
    holes, _ = cv2.connectedComponents(255 - m, connectivity=4)
    print(f"{name:8s} objects = {n - 1:3d}   holes+bg = {holes - 1}")
# Output:
# raw      objects =  59   holes+bg = 24    (some specks overlap; some holes merge)
# opened   objects =   1   holes+bg = 24
# cleaned  objects =   1   holes+bg = 1     (only the true background remains)

3. Granulometry: Sieving an Image by Size Intermediate

Opening with ever-larger SEs is a measurement instrument in its own right. Since opening removes everything smaller than the SE, the surviving foreground area as a function of SE radius is a decreasing curve, and its drops mark the sizes at which the image holds its content. This is granulometry, the original 1964 application: sieving crushed ore through ever-finer meshes, in software. The curve's negative derivative (the pattern spectrum) is effectively a histogram of object sizes computed without ever segmenting a single object, a trick worth remembering whenever objects touch or overlap too much to count, and a spiritual cousin of the multi-scale analysis in Chapter 4.

import cv2
import numpy as np

beans = (cv2.imread("coffee_beans.png", cv2.IMREAD_GRAYSCALE) > 128)
beans = beans.astype(np.uint8) * 255

areas = []
radii = range(1, 30)
for r in radii:
    se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * r + 1, 2 * r + 1))
    surviving = cv2.morphologyEx(beans, cv2.MORPH_OPEN, se)
    areas.append(int(np.count_nonzero(surviving)))

spectrum = -np.diff(areas)               # area destroyed at each radius
peak = radii[int(np.argmax(spectrum)) + 1]
print(f"dominant grain radius ~ {peak} px")
# Representative output:
# dominant grain radius ~ 14 px

4. Morphological Gradients: Boundaries From Differences Intermediate

Differences between the atoms and the original image isolate exactly the pixels each operator moves, and those pixels live on boundaries. Three standard combinations exist. The morphological gradient, $(A \oplus B) - (A \ominus B)$, yields a boundary ribbon roughly two pixels thick straddling the contour. The internal gradient $A - (A \ominus B)$ keeps the one-pixel rim just inside the object, and the external gradient $(A \oplus B) - A$ the rim just outside. On binary masks these are the standard way to extract object outlines before the more structured contour tracing of Section 6.6; on grayscale images the morphological gradient behaves like an edge-strength map, an unsigned cousin of the derivative filters from Chapter 3 and a precursor to the proper edge detectors of Chapter 9. One line each in OpenCV: cv2.morphologyEx(img, cv2.MORPH_GRADIENT, se), with the internal and external variants as ordinary subtractions.

5. Top-Hat & Black-Hat: Rescuing Thresholds From Bad Lighting Intermediate

The most valuable composition for grayscale work subtracts an opening from its input. The white top-hat, $f - (f \circ B)$, works because a grayscale opening with a large SE erases every bright structure narrower than the SE, leaving a clean estimate of the smooth background; subtracting that background leaves precisely the small bright structures, now sitting on a flat field. The black-hat, $(f \bullet B) - f$, does the same for small dark structures on bright backgrounds, ink on unevenly lit paper being the canonical case. This is the morphological answer to the uneven-illumination problem that motivated adaptive thresholding in Chapter 2: rather than adapting the threshold to the lighting, flatten the lighting and keep the simple global threshold.

import cv2
import numpy as np

# Page photographed under a desk lamp: strong left-to-right falloff.
page = cv2.imread("lamp_lit_page.png", cv2.IMREAD_GRAYSCALE)

_, global_otsu = cv2.threshold(page, 0, 255,
                               cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

# SE must dwarf the text strokes but stay smaller than the lighting scale.
se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (31, 31))
blackhat = cv2.morphologyEx(page, cv2.MORPH_BLACKHAT, se)  # dark ink -> bright
_, rescued = cv2.threshold(blackhat, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

print("ink fraction, naive Otsu :", f"{(global_otsu > 0).mean():.1%}")
print("ink fraction, black-hat  :", f"{(rescued > 0).mean():.1%}")
# Representative output:
# ink fraction, naive Otsu : 37.2%   <- entire dark half of page marked as ink
# ink fraction, black-hat  : 6.1%    <- text only, both halves of the page

6. Hit-or-Miss: Morphology as Exact Pattern Matching Advanced

One last composition rounds out the algebra. The hit-or-miss transform erodes the foreground with one SE and the background with a second, disjoint SE, keeping only pixels where both fit: a template match demanding specified foreground pixels and specified background pixels simultaneously. OpenCV encodes both SEs in a single kernel of $1$ (must be foreground), $-1$ (must be background), and $0$ (indifferent), via cv2.morphologyEx(mask, cv2.MORPH_HITMISS, kernel). A kernel of all $-1$s around a central $1$ finds isolated pixels; an L-shaped pattern finds right-angle corners. Hit-or-miss is the primitive behind the thinning algorithms that produce the skeletons of Section 6.5, where a rotating family of such templates peels away boundary pixels that can be removed without breaking connectivity.