Robust Outer Outline Separation in Binary Images Using Connected Components in OpenCV

Learn how to isolate an outer border from inner content in black-and-white images using OpenCV connected components - no inpainting, no thickness loss.

Separating an outer boundary from everything inside it is a common need when working with black-and-white graphics. Typical inputs include a thick rectangle around content, or a hand outline with internal details. The goal is to isolate the border from the inner shapes without deforming stroke thickness or leaving artifacts.

Where a straightforward approach breaks

A natural first attempt is to detect the largest external contour and remove it. The idea feels right for frames, but it struggles once the outer shape isn’t a rectangle and often leaves inpainting smudges. Here is a compact example of that approach:

import cv2
import numpy as np

def strip_frame_only(input_file,
                     frame_px=20,
                     patch_r=3):
    """
    Remove only the outer frame lines of thickness `frame_px`,
    preserving interior content.

    Args:
        input_file (str): Path to the input image.
        frame_px (int): Approximate pixel thickness of the outer border.
        patch_r (int): Radius for the inpainting algorithm.

    Returns:
        np.ndarray: Image with only the border removed.
    """
    bgr = cv2.imread(input_file)
    if bgr is None:
        raise FileNotFoundError(f"Cannot read: {input_file}")
    grayImg = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)

    thr = cv2.adaptiveThreshold(
        grayImg, 255,
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
        cv2.THRESH_BINARY_INV,
        blockSize=51, C=10)

    cnts, _ = cv2.findContours(
        thr, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if not cnts:
        return bgr.copy()
    biggest = max(cnts, key=cv2.contourArea)

    filledMask = np.zeros_like(grayImg)
    cv2.drawContours(filledMask, [biggest], -1, 255, thickness=cv2.FILLED)

    kk = frame_px // 2 * 2 + 1
    element = cv2.getStructuringElement(cv2.MORPH_RECT, (kk, kk))
    edgeMask = cv2.morphologyEx(filledMask, cv2.MORPH_GRADIENT, element)

    cleaned = cv2.inpaint(bgr, edgeMask, patch_r, cv2.INPAINT_TELEA)
    return cleaned

This route hinges on external contours only and estimates thickness via a morphological gradient. In practice, it may not preserve the exact stroke width of the outer boundary and can smear edges when inpainting. It also does not generalize reliably to outlines like hands or other non-rectangular shapes.

What’s really going on

When only external contours are retrieved, inner shapes are ignored in the contour hierarchy. That means you identify “something outer” but lose information about nested regions. Coupled with inpainting, the method removes pixels rather than semantically separating layers. The kernel choice approximates thickness, but outlines vary, and the inpainting step can leave visible artifacts. Suggestions that often arise in this context include examining contour hierarchy instead of using RETR_EXTERNAL, applying a flood fill strategy when images are strictly black and white, and validating the approach against more complex inputs before standardizing a solution.

A robust technique that generalizes beyond rectangles

A more reliable approach is to treat anything non-white as part of a “shape” and detect connected components. The first non-white pixel in reading order must belong to the outermost shape, because any inner region would be encountered only after its outer boundary has already appeared. With that, you can split the image into outer shape vs everything else without guessing thickness or inpainting. This assumes a white background and non-white content.

import cv2
import numpy as np

src = cv2.imread("shapeToSeparate.jpg")
if src is None:
    raise FileNotFoundError("Cannot read input image")

g = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)

# 1 for shape pixels, 0 for background (assumes white background)
mask01 = (g < 250) * np.uint8(1)

# First non-zero in scan order belongs to the outer shape
seed_idx = np.argmax(mask01)

# Label connected components on the binary mask
n_labels, labels = cv2.connectedComponents(mask01)

# Label value of the outer component
outer_id = labels.ravel()[seed_idx]

# Boolean mask of the outer component
outer_mask = labels == outer_id

# Build a side-by-side visualization: outer on the left, inner on the right
h, w, ch = src.shape
canvas = np.full((h, 2 * w, ch), 255, dtype=np.uint8)

canvas[:, :w][outer_mask] = src[outer_mask]
canvas[:, w:][~outer_mask] = src[~outer_mask]

This separates the outer boundary from all interior content while keeping the original stroke thickness intact, because no destructive operations like inpainting are used. The result is placed on a white canvas twice the original width, with the outer shape rendered on the left and everything else on the right. You can adapt how the two parts are output; the key is that the segmentation is based on connectivity and a well-defined outer component, not on contour guesses or morphological edge widths.

Why this matters

When your inputs are strictly black-and-white compositions, reliably partitioning the outer outline from internal content unlocks predictable post-processing. For example, working with design templates placed on hands, fingers, or cheeks benefits from a clean split between the enclosing outline and the design inside. With the connected-components approach, the separation is consistent across rectangles, hand outlines, and other complex silhouettes, as long as the background is white and anything non-white is considered part of a shape. This method has also been demonstrated on more complicated compositions beyond the simple rectangular frame case.

Practical takeaways

If the background is white and the ink is non-white, prefer a connectivity-based solution over external-contour-only heuristics and inpainting. It preserves thickness without smudging and generalizes to non-rectangular outlines. If you later need to push beyond the white-background assumption or handle more intricate hierarchies of nested regions, explore contour hierarchy analysis or a flood fill approach aligned with strict black-and-white inputs, and validate on a broader set of representative images before committing to a pipeline.

In short, define “shape” versus “background” up front, use connected components to locate the true outer shape, and separate results without altering the pixels you want to keep. That keeps edges crisp and behavior consistent, even when the outer boundary isn’t a simple frame.