Extract most central area in a Binary Image

Question

I am processing binary images, and was previously using this code to find the largest area in the binary image:

# Use the hue value to convert to binary
thresh = 20
thresh, thresh_img = cv2.threshold(h, thresh, 255, cv2.THRESH_BINARY)
cv2.imshow('thresh', thresh_img)
cv2.waitKey(0) 
cv2.destroyAllWindows()                        
# Finding Contours
# Use a copy of the image since findContours alters the image

contours, _ = cv2.findContours(thresh_img.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

#Extract the largest area
c = max(contours, key=cv2.contourArea) 

This code isn't really doing what I need it to do, now I think it would better to extract the most central area in the binary image.

Binary Image Largest Image

This is currently what the code is extracting, but I am hoping to get the central circle in the first binary image extracted.

Answer 1

OpenCV comes with a point-polygon test function (for contours). It even gives a signed distance, if you ask for that.

I'll find the contour that is closest to the center of the picture. That may be a contour actually overlapping the center of the picture.

Timings, on my quadcore from 2012, give or take a millisecond:

• findContours: ~1 millisecond
• all pointPolygonTests and argmax: ~1 millisecond

mask = cv.imread("fkljm.png", cv.IMREAD_GRAYSCALE)
(height, width) = mask.shape
ret, mask = cv.threshold(mask, 128, 255, cv.THRESH_BINARY) # required because the sample picture isn't exactly clean

# get contours
contours, hierarchy = cv.findContours(mask, cv.RETR_LIST | cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)

center = (np.array([width, height]) - 1) / 2

# find contour closest to center of picture
distances = [
    cv.pointPolygonTest(contour, center, True) # looking for most positive (inside); negative is outside
    for contour in contours
]
iclosest = np.argmax(distances)
print("closest contour is", iclosest, "with distance", distances[iclosest])

# draw closest contour
canvas = cv.cvtColor(mask, cv.COLOR_GRAY2BGR)
cv.drawContours(image=canvas, contours=[contours[iclosest]], contourIdx=-1, color=(0, 255, 0), thickness=5)

closest contour is 45 with distance 65.19202405202648

---

a cv.floodFill() on the center point can also quickly yield a labeling on that blob... assuming the mask is positive there. Otherwise, there needs to be search.

(cx, cy) = center.astype(int)
assert mask[cy,cx], "floodFill not applicable"

# trying cv.floodFill on the image center
mask2 = mask >> 1 # turns everything else gray
cv.floodFill(image=mask2, mask=None, seedPoint=center.astype(int), newVal=255)

# use (mask2 == 255) to identify that blob

This also takes less than a millisecond.

---

Some practically faster approaches might involve a pyramid scheme (low-res versions of the mask) to quickly identify areas of the picture that are candidates for an exact test (distance/intersection).

• Test target pixel. Hit (positive)? Done.
• Calculate low-res mask. Per block, if any pixel is positive, block is positive.
• Find positive blocks, sort by distance, examine closer all those that are within sqrt(2) * blocksize of the best distance.

Answer 2

There are several ways you define "most central." I chose to define it as the region with the closest distance to the point you're searching for. If the point is inside the region, then that distance will be zero.

I also chose to do this with a pixel-based approach rather than a polygon-based approach, like you're doing with findContours().

Here's a step-by-step breakdown of what this code is doing.

1. Load the image, put it into grayscale, and threshold it. You're already doing these things.
2. Identify connected components of the image. Connected components are places where there are white pixels which are directly connected to other white pixels. This breaks up the image into regions.
3. Using np.argwhere(), convert a true/false mask into an array of coordinates.
4. For each coordinate, compute the Euclidean distance between that point and search_point.
5. Find the minimum within each region.
6. Across all regions, find the smallest distance.

import cv2
import numpy as np

img = cv2.imread('test197_img.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_, thresh_img = cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
n_groups, comp_grouped = cv2.connectedComponents(thresh_img)
components = []
search_point = [600, 150]
for i in range(1, n_groups):
    mask = (comp_grouped == i)
    component_coords = np.argwhere(mask)[:, ::-1]
    min_distance = np.sqrt(((component_coords - search_point) ** 2).sum(axis=1)).min()
    components.append({
        'mask': mask,
        'min_distance': min_distance,
    })
closest = min(components, key=lambda x: x['min_distance'])['mask']

Output: