Contours and Morphology

## What a contour is here In OpenCV a contour is a closed curve traced along the boundary of a connected region of non-zero pixels. It is not an edge map and not a list of edge pixels: it is an **ordered** sequence of points that walks around one blob, which is what makes downstream measurement (area, perimeter, bounding box, shape matching) possible. ## The input contract `cv2.findContours` wants a single-channel, 8-bit image. Two rules follow from that: 1. **It must already be binary in spirit.** The function does not threshold. It partitions pixels into background (value 0) and foreground (anything non-zero). Hand it an un-thresholded grayscale frame and it will not raise - it will happily trace the boundary between the few true-zero pixels and everything else, returning a small number of huge, meaningless contours, or thousands of noisy ones. This is the classic silent-wrong-answer on this API. 2. **Objects must be white on black.** If your parts are dark on a light background, you get the *background's* boundary instead. Fix it at threshold time with `cv2.THRESH_BINARY_INV`, or invert with `cv2.bitwise_not`. Since OpenCV 3.2 the input array is no longer overwritten, so the defensive `binary.copy()` you see in older code is unnecessary in OpenCV 4 and 5. ## The two mandatory flags **Retrieval mode** decides *which* contours come back and whether nesting is recorded. `cv2.RETR_EXTERNAL` returns only the outermost contours - the usual choice for counting solid parts. `cv2.RETR_LIST` returns all of them, including the boundaries of holes, with no parent/child relationships. `cv2.RETR_CCOMP` gives a two-level result, and `cv2.RETR_TREE` the full nesting tree. **Approximation method** decides how many points each contour carries. `cv2.CHAIN_APPROX_NONE` stores every single boundary pixel; `cv2.CHAIN_APPROX_SIMPLE` collapses straight horizontal, vertical and diagonal runs to their endpoints, so an axis-aligned rectangle comes back as four points instead of hundreds. `SIMPLE` is the default choice: it is smaller and faster and loses nothing that area, perimeter or bounding-box code cares about. Use `NONE` only when you genuinely need every boundary pixel, for example to sample intensities along the outline. ## The return value In OpenCV 4 and OpenCV 5: ``` contours, hierarchy = cv2.findContours(binary, mode, method) ``` `contours` is a Python list (or tuple) of NumPy arrays. Each array has shape `(N, 1, 2)` and dtype `int32` - N points, each an `(x, y)` pair, with a redundant middle axis that is a legacy of the C++ `vector<Point>` binding. That middle axis is why `cnt[:, 0, :]` or `cnt.reshape(-1, 2)` shows up everywhere, and why `cnt.shape[0]` (not `len(cnt[0])`) is the point count. `hierarchy` is an array of shape `(1, N, 4)` describing nesting; when a mode records no relationships the unused slots are `-1`. If no contours are found, `contours` is empty and `hierarchy` is `None` - guard for that before indexing it. OpenCV 3 returned `(image, contours, hierarchy)`. Interviewers like this detail because it is the single most common breakage when old tutorials are pasted into a modern environment; the symptom is `ValueError: not enough values to unpack`. ## Coordinates and drawing back Contour points are `(x, y)` - column first - while NumPy indexing on the same image is `img[y, x]`. Mixing the two is a routine bug. `cv2.drawContours(image, contours, contourIdx, color, thickness)` takes the **list**, not one contour: to draw a single contour you pass `[cnt]`. `contourIdx=-1` draws all of them, and `thickness=cv2.FILLED` (-1) fills the interior, which is a handy way to rebuild a clean mask from selected contours. Drawing onto a single-channel image with a `(0, 255, 0)` colour silently uses only the first component, so convert to 3-channel first if you want colour. ## Practical sequence The everyday recipe is: grayscale, threshold (global, Otsu or adaptive), a morphological clean-up pass, then `findContours` with `RETR_EXTERNAL` and `CHAIN_APPROX_SIMPLE`, then filter the result by `cv2.contourArea` to drop specks before measuring what survives. Skipping the clean-up step is why naive pipelines report hundreds of one-pixel contours.