如何使用 OpenCV findContours 检测相交形状？

Question

我在黑白图像中有两个相交的椭圆。我正在尝试使用 OpenCV findContours 使用此代码（和下面的附图）将单独的形状识别为单独的轮廓。

import numpy as np
import matplotlib.pyplot as plt

import cv2
import skimage.morphology

img_3d = cv2.imread("C:/temp/test_annotation_overlap.png")
img_grey = cv2.cvtColor(img_3d, cv2.COLOR_BGR2GRAY)
contours = cv2.findContours(img_grey, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[-2]

fig, ax = plt.subplots(len(contours)+1,1, figsize=(5, 20))

thicker_img_grey = skimage.morphology.dilation(img_grey, skimage.morphology.disk(radius=3))
ax[0].set_title("ORIGINAL IMAGE")
ax[0].imshow(thicker_img_grey, cmap="Greys")

for i, contour in enumerate(contours):
    new_img = np.zeros_like(img_grey)
    cv2.drawContours(new_img, contour, -1,  (255,255,255), 10)
    ax[i+1].set_title(f"Contour {i}")
    ax[i+1].imshow(new_img, cmap="Greys")

plt.show()

然而找到了四个轮廓，其中none个是原始轮廓：

如何配置 OpenCV.findContours 来识别两个不同的形状？（注意我已经玩过 Hough 圆，发现它对我正在分析的图像不可靠）

Answer 1

从哲学上讲，您想找到两个圆，因为您搜索它们时，您期望中心和半径。从图形上看，图形是相连的，我们可以看到它们是分开的，因为我们知道“圆”是什么，并推断出与重叠部分相匹配的坐标。

那么如何找到每个轮廓的最小外接圆（或者在某些情况下 fitEllipse 并使用它们的参数）：https://docs.opencv.org/master/dd/d49/tutorial_py_contour_features.html

然后说在清晰的图像中画出那个圆，并通过蒙版获取不为零的像素坐标，或者通过逐步画出圆来计算它们。

然后将这些坐标与其他轮廓中的坐标进行一定精度的比较，并将匹配的坐标附加到当前轮廓中。

最后：在清晰的 canvas 上绘制扩展轮廓，并对单个非重叠圆应用 HoughCircles。（或计算圆心和半径，圆的坐标并与轮廓比较精度。）

Answer 2

也许我对这种方法有点矫枉过正，但它可以用作一种可行的方法。您可以在图像上找到所有轮廓 - 您将得到两个像“半圆”的轮廓，相交的轮廓和两个相交圆的外部形状的轮廓。最小的三个轮廓应该是两个半圆和交点。如果你从这三个轮廓中绘制两个的组合，你将得到三个蒙版，其中两个将具有一个半圆和交点的组合。如果您在面具上执行关闭，您将得到您的圈子。然后你应该简单地做一个算法来检测哪两个面具代表一个完整的圆圈，你会得到你的结果。这是示例解决方案：

import numpy as np
import cv2


# Function for returning solidity of contour - ratio of contour area to its 
# convex hull area.
def checkSolidity(cnt):
    area = cv2.contourArea(cnt)
    hull = cv2.convexHull(cnt)
    hull_area = cv2.contourArea(hull)
    solidity = float(area)/hull_area
    return solidity


img_orig = cv2.imread("circles.png")
# Had to dilate the image so the contour was completly connected.
img = cv2.dilate(img_orig, np.ones((3, 3), np.uint8))
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # Grayscale transformation.
# Otsu threshold.
thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)[1]
# Search for contours.
contours = cv2.findContours(thresh, cv2.CHAIN_APPROX_NONE, cv2.RETR_TREE)[0]

# Sorting contours from smallest to biggest.
contours.sort(key=lambda cnt: cv2.contourArea(cnt))

# Three contours - two semi circles and the intersection of the circles.
cnt1 = contours[0]
cnt2 = contours[1]
cnt3 = contours[2]

# Create three empty images
h, w = img.shape[:2]
mask1 = np.zeros((h, w), np.uint8)
mask2 = np.zeros((h, w), np.uint8)
mask3 = np.zeros((h, w), np.uint8)

# Draw all combinations of two out of three contours on the masks.
# The goal here is to draw one semicircle and the intersection together.

cv2.drawContours(mask1, [cnt1], 0, (255, 255, 255), -1)
cv2.drawContours(mask1, [cnt3], 0, (255, 255, 255), -1)

cv2.drawContours(mask2, [cnt2], 0, (255, 255, 255), -1)
cv2.drawContours(mask2, [cnt3], 0, (255, 255, 255), -1)

cv2.drawContours(mask3, [cnt1], 0, (255, 255, 255), -1)
cv2.drawContours(mask3, [cnt2], 0, (255, 255, 255), -1)


# Perform closing operation on the masks so that you get uniform contours.
kernel_size = 25
kernel = np.ones((kernel_size, kernel_size), np.uint8)
mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, kernel)
mask2 = cv2.morphologyEx(mask2, cv2.MORPH_CLOSE, kernel)
mask3 = cv2.morphologyEx(mask3, cv2.MORPH_CLOSE, kernel)

masks = []  # List for storing all the masks.
masks.append(mask1)
masks.append(mask2)
masks.append(mask3)

# List where you will append solidity of the found biggest contour of every mask.
solidity = []
for mask in masks:
    cnts = cv2.findContours(mask, cv2.CHAIN_APPROX_NONE, cv2.RETR_TREE)[0]
    cnt = max(cnts, key=lambda c: cv2.contourArea(c))
    s = checkSolidity(cnt)
    solidity.append(s)


# Index of the mask with smallest solidity.
min_solidity = solidity.index(min(solidity))
# The mask with the contour that has smallest solidity should be the one that
# has two semicirles drawn instead of one semicircle and the intersection. 
#You could build a better function to check which mask is the one with   
# two semicircles... like maybe the contour with the largest 
# height and width of the bounding box etc.
# I chose solidity because it is enough for this example.

# Selection of colors.
colors = {
    0: (0, 0, 255),
    1: (0, 255, 0),
    2: (255, 0, 0),
}

# Draw contours of the mask other two masks - those two that have the        
# semicircle and the intersection.
for i, s in enumerate(solidity):
    if s != solidity[min_solidity]:
        cnts = cv2.findContours(
            masks[i], cv2.CHAIN_APPROX_NONE, cv2.RETR_TREE)[0]
        cnt = max(cnts, key=lambda c: cv2.contourArea(c))
        cv2.drawContours(img_orig, [cnt], 0, colors[i], 1)

# Display result
cv2.imshow("img", img_orig)
cv2.waitKey(0)
cv2.destroyAllWindows()

结果：

Answer 3

为了参考，我将 post 我根据此处的一些想法以及其他一些想法提出的解决方案。此解决方案的效率为 99.9%，并且从图像中恢复椭圆通常包括许多重叠、包含以及其他图像噪声（例如线条、文本等）。

代码太长发到post这里但是伪代码如下

分割图像
- 运行 cv2 findContours with RETR_EXTERNAL 获取图像中的单独区域
- 对于每张图像，填充内部，应用蒙版，并独立于其他区域提取要处理的区域。
- 每个区域独立执行剩余步骤
运行 cv2 findContours with RETR_LIST 获取所有内部和外部轮廓
对于找到的每个轮廓，应用多边形平滑以减少像素化的影响
对于每个平滑轮廓，识别该轮廓内具有相同曲率符号的连续段，即完全向右弯曲或向左弯曲的段（仅计算角度和符号变化）
在每个段内，用最小二乘拟合椭圆模型 (scikit-learn EllipseModel)
对原始图像执行 Lee 算法以计算每个像素到白色像素的最小距离
对于每个模型，执行贪婪的局部邻域搜索以改进与原始模型的拟合 - 拟合是从 lee 算法的输出到白色像素的拟合椭圆最大距离

不简单也不优雅，但对于我正在处理的内容来说是高度准确的，这些内容是通过大量图像的人工审查确认的。

如何使用 OpenCV findContours 检测相交形状？

How to detect intersecting shapes with OpenCV findContours?

python

opencv

contour

shape-recognition