Connected Components & Region Properties

"For years I was just foreground. Then one Tuesday a two-pass algorithm gave me a name, an area, a centroid, and a bounding box. I am component 17 now. I contain 4,212 pixels and my eccentricity is none of your business."

A Freshly Labeled Connected Component

The previous section delivered a clean mask: one connected blob per physical object, no speckle, no pinholes. The definitions are also already in place: Section 6.1 defined a connected component as a maximal set of mutually reachable pixels under a chosen adjacency. What remains is the algorithmic step of actually assigning every foreground pixel an integer identity (this pixel belongs to object 3), and then the measurement step of summarizing each identity into properties a decision rule can consume. Both steps are humble, and the second is arguably the most economically productive operation in this book: most deployed vision systems are, at bottom, regionprops plus an if-statement.

1. Labeling: Giving Pixels an Identity Beginner

A labeling of a binary image is an integer image of the same size in which background pixels hold 0 and every foreground pixel holds the index of its component: all pixels of the first object hold 1, the second 2, and so on. Figure 6.4.1 shows the transformation on a small grid, together with the measurements that fall out of it almost for free.

The simplest correct algorithm is flood fill: scan for an unlabeled foreground pixel, assign it the next label, and propagate that label outward through neighbors (breadth-first or depth-first) until the component is exhausted; repeat. It visits each pixel a constant number of times, so it is linear in image size, and it makes the connectivity definition of Section 6.1 executable in a screenful of code:

import numpy as np
from collections import deque

def label_floodfill(mask, connectivity=8):
    """Connected-component labeling by BFS flood fill."""
    offs = [(-1,0),(1,0),(0,-1),(0,1)]
    if connectivity == 8:
        offs += [(-1,-1),(-1,1),(1,-1),(1,1)]
    h, w = mask.shape
    labels = np.zeros((h, w), np.int32)
    current = 0
    for y in range(h):
        for x in range(w):
            if mask[y, x] and not labels[y, x]:
                current += 1                      # found a new object
                queue = deque([(y, x)])
                labels[y, x] = current
                while queue:                      # spread the label
                    cy, cx = queue.popleft()
                    for dy, dx in offs:
                        ny, nx = cy + dy, cx + dx
                        if (0 <= ny < h and 0 <= nx < w
                                and mask[ny, nx] and not labels[ny, nx]):
                            labels[ny, nx] = current
                            queue.append((ny, nx))
    return labels, current

yy, xx = np.mgrid[0:9, 0:9]
ring = ((np.abs(xx - 4) + np.abs(yy - 4)) == 3)
print(label_floodfill(ring, 8)[1], label_floodfill(ring, 4)[1])
# Output:
# 1 12        (the Section 6.1 diamond: one object 8-connected, twelve 4-connected)

Production labelers use a different classic, the two-pass algorithm: a single raster scan assigns provisional labels by looking only at already-visited neighbors (up and left), records an equivalence whenever two different provisional labels meet (a U-shaped object's two arms, discovered to be one object at the bottom of the U), and resolves all equivalences with a union-find structure before a second scan rewrites final labels. Two sequential, cache-friendly sweeps and a near-constant-time union-find make it extremely fast; the open YACCLAB benchmark tracks a whole zoo of refinements (block-based scanning, SIMD, GPU variants) that push hundreds of megapixels per second. You will never need to write one, but knowing the mechanism explains the otherwise mysterious phrase "label equivalence" in library documentation, and explains why labels come out in raster order.

2. The Production Call: connectedComponentsWithStats Beginner

OpenCV bundles labeling with the most common measurements in a single call, which is the workhorse of counting pipelines:

import cv2
import numpy as np

mask = cv2.imread("cleaned_parts_mask.png", cv2.IMREAD_GRAYSCALE)

n, labels, stats, centroids = cv2.connectedComponentsWithStats(
    mask, connectivity=8)

print(f"{n - 1} objects")               # label 0 is the background
for i in range(1, n):
    x, y, w, h, area = stats[i]         # bbox corner, bbox size, pixel count
    cx, cy = centroids[i]
    print(f"  #{i}: area={area:5d}  bbox=({x},{y},{w}x{h})  "
          f"centroid=({cx:.1f},{cy:.1f})")
# Representative output:
# 4 objects
#   #1: area= 8120  bbox=(64,40,112x99)   centroid=(119.6,89.2)
#   #2: area= 7903  bbox=(241,38,109x101) centroid=(295.0,88.8)
#   #3: area=  311  bbox=(402,71,25x31)   centroid=(414.1,86.0)
#   #4: area= 8045  bbox=(78,210,110x100) centroid=(132.8,259.7)

The stats matrix supports the single most useful post-cleanup operation: area filtering. Component #3 above is an order of magnitude smaller than its siblings, almost certainly debris that survived the opening of Section 6.3. Rebuilding the mask while dropping every component outside an area band is three lines (keep = np.isin(labels, good_ids) after selecting good_ids from the stats column), and unlike a larger opening it removes the debris with zero distortion of the survivors. Area filtering and morphological cleanup are complements, not rivals: morphology fixes pixel-scale damage within objects, area filtering enforces object-scale sanity between them.

3. regionprops: The Measurement Toolkit Intermediate

When a pipeline needs more than areas and boxes, scikit-image's regionprops is the standard instrument. It computes dozens of per-region properties lazily, and its sibling regionprops_table emits them as columnar data ready for pandas, which is the moment a vision problem officially becomes a data-science problem. The properties worth knowing by heart are summarized in Table 6.4.1.

Several of these will be derived properly in Section 6.6 (centroid and orientation from moments, perimeter from contours); here they are consumers' goods. The code below runs the full measurement pipeline on a parts image and lands the results in a dataframe:

import pandas as pd
from skimage import measure

lbl = measure.label(mask > 0, connectivity=2)        # 8-connectivity in 2D
df = pd.DataFrame(measure.regionprops_table(
    lbl,
    properties=["label", "area", "centroid", "eccentricity",
                "solidity", "euler_number"]))
print(df.round(3).to_string(index=False))
# Representative output:
#  label  area  centroid-0  centroid-1  eccentricity  solidity  euler_number
#      1  8120      89.21      119.62         0.214     0.987             1
#      2  7903      88.83      295.04         0.198     0.991             0
#      3   311      86.04      414.13         0.892     0.704             1
#      4  8045     259.72     132.81          0.226     0.989             1

4. From Measurements to Decisions Beginner

The last step of a counting or gating pipeline is almost embarrassingly simple, and that simplicity is the selling point. A bolt-kit verifier might require exactly 12 regions with area in [7000, 9000] and eccentricity below 0.4 (the washers), plus 4 regions with eccentricity above 0.85 (the bolts), and reject otherwise. Such rules execute in microseconds, can be reviewed line by line in an audit, and fail loudly rather than plausibly. Their weakness is equally plain: they generalize exactly as far as the engineer's foresight. The moment classes overlap in every measured feature, rules give out, and that is the cliff edge where Section 6.6's richer shape descriptors, then Chapter 16's learned classifiers, take over.