Binary images and morphology

Updated 03 Nov 2026

•
Binary conversion and thresholding
- •
  Binary image -> foreground 1 and background 0; OpenCV commonly stores these as 255 and 0
  - •
    foreground is the object of interest, not necessarily the bright part of the original image
  - •
    state the polarity before applying morphology; invert when dark objects should be foreground
- •
  Global threshold
  - •
    $f_B(i, j) = 1$ if $f_G(i, j) > T$ ; otherwise $f_B(i, j) = 0$
  - •
    equality belogns to background in this convention
  - •
    one threshold is applied across the image; uneven illumination can make this unsuitable
- •
  Otsu's method
  - •
    selects a global threshold from the intensity histogram, rather than requiring a manual $T$ .
  - •
    maximizes between-class variance: $\sigma_B^2(T)=w_0(T)w_1(T)[\mu_0(T)-\mu_1(T)]^2$ .
  - •
    $w_0,w_1$ are class proportions; $\mu_0,\mu_1$ are their intensity means.
  - •
    equivalent to minimizing within-class variance for this two-class partition.
  - •
    often useful for separated foreground/background distributions; it does not understand object meaning.
  - •
    overlap, severe class imbalance, and uneven illumination can give poor segmentation.
  - •
    constant images have no meaningful intensity separation; do not treat an automatically returned threshold as proof of two classes.
- •
  for noisy input, asses suitable denoising before threshold selection
  - •
    over-smoothing can merge objects or erase small features
•
Structuring element, hit, and fit
- •
  Structuring element (SE) -> a footprint defining which relative positions participate in a morphological operation.
  - •
    similar to a neighborhood kernel, but active positions specify a shape rather than averaging weights.
  - •
    record its shape, size, anchor/origin, and image-border convention.
  - •
    zero entries are ignored in ordinary dilation/erosion; they do not demand background matches.
- •
  Common footprints
  - •
    filled square -> all positions active.
  - •
    plus/cross -> center and horizontal/vertical neighbors.
  - •
    X -> center and diagonal neighbors.
  - •
    horizontal/vertical line -> favors the corresponding orientation.
  - •
    slash/backslash -> favors a diagonal direction.
  - •
    a large or poorly matched SE can remove wanted structures or merge distinct objects.
- •
  Hit -> at least one active footprint position overlaps foreground.
- •
  Fit -> every active footprint position overlaps foreground.
- •
  Reflection convention
  - •
    write $S_z$ for SE $S$ translated to location $z$ and $\hat S=\{-s:s\in S\}$ for its reflection.
  - •
    erosion tests whether $S_z$ fits in $A$ ; standard set dilation tests whether $\hat S_z$ hits $A$ .
  - •
    for centered symmetric footprints, reflection makes no difference; asymmetric footprints require care.
- •
  do not confuse an ordinary hit test with the hit-or-miss transform, which matches specified foreground and background patterns together.
•
Basic morphology
- •
  let $A$ be foreground set and use the same SE $S$ throughout each compound operation
- •
  Dilation -> $A\oplus S$
  - •
    set the output to foreground wherever the hit condition holds
  - •
    with an SE containing its origin, expands foreground and can join nearby components
- •
  Erosion -> $A\ominus S$
  - •
    keep foreground only where the SE fits entirely
  - •
    with an SE containing its origin, shrinks foreground and can remove thin bridges or small objects
- •
  Opening -> $A\circ S = (A \ominus S)\oplus S$
  - •
    erosion followed by dilation
  - •
    removes foreground structures too small/narrow for the SE; can break thin connections
  - •
    the dilation doesn't restore everything erosion removed
- •
  Closing -> $A\bullet S = (A \oplus S)\ominus S$
  - •
    dilation followed by erosion
  - •
    can close small background gaps/holes and connect nearby foreground regions
  - •
    doesn't preserve every object's proportions or fill holes of arbitrary size
- •
  Boundary extraction -> $\partial_S A=A\setminus(A\ominus S)$ .
  - •
    subtract the eroded foreground from the original to obtain an inner boundary.
  - •
    boundary thickness and corner behavior depend on the SE
- •
  Useful checks
  - •
    ideal set opening does not add foregound; closing does not remove it
  - •
    both are idempotent with the same SE: repeating the completed operation does not keep changing the set
  - •
    finite-image borders/cropping can affect these properties state how outside pixels are treated
•
Filling and connected components
- •
  Region/flood filling -> grow a connected region from a seed until its boundary is reached
  - •
    similar to a paint-bucket tool; connectivity and the acceptance rule define where filling spreads
- •
  Hole filling -> fill background components that are not connected to the image exterior
  - •
    flood the exterior background, then distinguish it from enclosed background
  - •
    unlike closing, this is not limited by a chosen small SE's hole size
  - •
    specify background connectivity; diagonal gaps can change whetehr a region counts as enclosed
- •
  Connected-component labeling -> assign one integer ID to each connected foreground component; background remains 0
  - •
    a region-analysis operation often used after morphology, not inherently an erosion/dilation operation
  - •
    4-connectivity -> horizontal/vertical neighbors
  - •
    8-connectivity -> also includes diagonals; diagonally touching pixels may become one component
- •
  Two-pass labeling, row-major scan
  1. 1.
    for each foreground pixel, inspect already-visited neighbors
    
    1.
    under 4-connectivity: left and up
    
    2.
    under 8-connectivityy: also upper-left and upper-right
  2. 2.
    if none is labeled, assign a new provisional label
  3. 3.
    otherwise reuse a neighbor's label and record equivalences when several labels meet
  4. 4.
    resolve equivalence classes, then replace provisional labels with their representatives in a second pass
    
    1.
    union-find is one way to maintain these equivalences
    
    2.
    the representative can be the smallest label, but its numeric value is not the object's identity
- •
  labels support component counts, areas, and bounding boxes; use nearest-neighbor interpolation if resizing a label map
•
Thinning, skeletons, and convex hulls
- •
  Thinning
  - •
    iteratively removes selected boundary pixels while aiming to preserve connectivity/topology
  - •
    produces thin, often one-pixel-wide curves; junctions and discrete geometry complicate a literal width guarantee
  - •
    repeated ordinary erosion is not quivalent: it can disconnect or erase objects
- •
  Thickening
  - •
    adds pixels according to pattern/topology rules, often as the dual of thinning
  - •
    distinct from ordinary dilation, which simply expands according to an SE
- •
  Skeletonization
  - •
    represents an object's structure with a reduced set of centerline-like pixels
  - •
    thinning algorithms are one way to obtain a skeleton; the terms overlap in software libraries
  - •
    a medial axis relates the skeleton to centers of maximal inscribed disks
    
    •
    distance-to-background values can retain local radius/thickness information
    
    •
    a bare binary skeleton alone doesn't retain all th original shape information
  - •
    small boundary irregularities can create spurs; pruning changes structure and needs justification
- •
  Convex hull
  - •
    smallest convex set containing the foreground, represented on the image grid
  - •
    convex means the segment joining any two points stays within the set
  - •
    not the polygon with the fewest straight edges, and not a tight outline around concavities
  - •
    a hull of all foreground may bridge separate objects; compute per component when that is not intended
- •

Python: binary masks and morphology

•
run after require_u8 from teaching code 1; uses the existing OpenCV, NumPy, and scikit-image dependencies.
•
uses a centered symmetric $3\times3$ square and explicit zero-valued morphology borders.
•
filling pads the mask with background so flood filling can reach the exterior even when an object touches the original corner.
- •
  the example uses 4-connected background filling; foreground labeling connectivity is selected separately.
•
synthetic arrays stay in memory; no images or diagrams are generated or saved.

import cv2
import numpy as np
from skimage.morphology import skeletonize, thin, convex_hull_image

def binary_demo(gray, threshold=None, connectivity=8):
      require_u8(gray, color=False)
      if connectivity not in (4, 8):
          raise ValueError("connectivity must be 4 or 8")
      if threshold is None:
          T, mask = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
      else:
          if not np.isfinite(threshold) or not 0 <= threshold <= 255:
              raise ValueError("threshold must be finite in 0..255")
          T, mask = cv2.threshold(gray, float(threshold), 255, cv2.THRESH_BINARY)
      S = np.ones((3, 3), dtype=np.uint8)
      border = dict(borderType=cv2.BORDER_CONSTANT, borderValue=0)
      eroded = cv2.erode(mask, S, **border)
      dilated = cv2.dilate(mask, S, **border)
      opened = cv2.morphologyEx(mask, cv2.MORPH_OPEN, S, **border)
      closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, S, **border)
      padded = np.pad(mask, 1, constant_values=0)
      flooded = padded.copy()
      cv2.floodFill(flooded, None, (0, 0), 255, flags=4)
      holes = cv2.bitwise_not(flooded[1:-1, 1:-1])
      count, labels, stats, centroids = cv2.connectedComponentsWithStats(mask, connectivity=connectivity)
      foreground = mask != 0
      hull = convex_hull_image(foreground) if foreground.any() else foreground.copy()
      return {
          "threshold": T, "mask": mask, "eroded": eroded, "dilated": dilated,
          "opened": opened, "closed": closed, "boundary": cv2.subtract(mask, eroded),
          "filled": cv2.bitwise_or(mask, holes), "labels": labels,
          "count": count - 1, "stats": stats[1:], "centroids": centroids[1:],
          "thin": thin(foreground), "skeleton": skeletonize(foreground), "hull": hull,
      }

levels = np.array([[0, 100, 101, 255]], dtype=np.uint8)
assert binary_demo(levels, threshold=100)["mask"].tolist() == [[0, 0, 255, 255]]
ring = np.zeros((9, 9), dtype=np.uint8)
ring[2:7, 2:7] = 255
ring[3:6, 3:6] = 0
result = binary_demo(ring)
assert result["count"] == 1 and result["filled"][4, 4] == 255
assert np.count_nonzero(result["mask"]) == 16
assert np.count_nonzero(result["filled"]) == 25
assert np.all(result["skeleton"] <= (ring != 0))
diagonal = np.zeros((5, 5), dtype=np.uint8)
diagonal[1, 1] = diagonal[2, 2] = 255
assert binary_demo(diagonal, connectivity=4)["count"] == 2
assert binary_demo(diagonal, connectivity=8)["count"] == 1
assert binary_demo(np.zeros((5, 5), dtype=np.uint8))["count"] == 0

Linked references 1

digital-image-processing-polban

◌ Explore connections in Graph view

Binary images and morphology

Binary conversion and thresholding

Structuring element, hit, and fit

Basic morphology

Filling and connected components

Thinning, skeletons, and convex hulls

Python: binary masks and morphology

Linked references 1