高噪声二值图像中圆形形状的检测

Question

我试图通过OpenCV（Python）的图像预处理技术来检测黑白足球。我的想法如下；

1. 处理图像（例如模糊的二进制照片）
2. 找到多个候选足球（例如通过轮廓检测）
3. 调整这些候选者的大小（例如48x48px），并在一个非常简单的神经网络中输入其像素对应的布尔值（0=黑色像素，1=白色像素），然后为每个候选者输出置信度值
4. 确定足球是否存在于照片中，以及球的最可能位置

我一直在寻找合适的候选人。目前，这是我的做法；

步骤1：原始图像

步骤2：模糊的图像（Medianblur，内核7）

步骤3：生成二值图像A生成二值图像B

然后我使用findContours在二值图像上查找轮廓。如果在二进制图像B上找不到候选对象（使用最小和最大边界框阈值），FindContentours将在二进制图像a上运行（并返回候选对象）。如果在二值图像B上发现一个或多个候选图像，则原始图像将重新模糊（使用核15），二值图像C将用于查找轮廓并返回候选图像。请参阅：生成的二进制图像C

这是生成这些二进制图像的代码：

def generateMask(imgOriginal, rgb, margin):
  lowerLimit = np.asarray(rgb)
  upperLimit = lowerLimit+margin

  # switch limits if margin is negative
  if(margin < 0):
    lowerLimit, upperLimit = upperLimit, lowerLimit

  mask = cv.inRange(imgOriginal, lowerLimit, upperLimit)

  return mask

# generates a set of six images with (combinations of) mask(s) applied
def applyMasks(imgOriginal, mask1, mask2):
  # applying both masks to original image
  singleAppliedMask1 = cv.bitwise_and(imgOriginal, imgOriginal, mask = mask1) #res3
  singleAppliedMask2 = cv.bitwise_and(imgOriginal, imgOriginal, mask = mask2) #res1

  # applying masks to overlap areas in single masked and original image
  doubleAppliedMaskOv1 = cv.bitwise_and(
    imgOriginal,
    singleAppliedMask1,
    mask = mask2
  ) #res4
  doubleAppliedMaskOv2 = cv.bitwise_and(
    imgOriginal,
    singleAppliedMask2,
    mask = mask1
  ) #res2

  # applying masks to joint areas in single masked and original image
  doubleAppliedMaskJoin1 = cv.bitwise_or(
    imgOriginal, 
    singleAppliedMask1, 
    mask = mask2
  ) #res7
  doubleAppliedMaskJoin2 = cv.bitwise_or(
    imgOriginal,
    singleAppliedMask2,
    mask = mask1
  ) #res6

  return (
    singleAppliedMask1, singleAppliedMask2,
    doubleAppliedMaskOv1, doubleAppliedMaskOv2,
    doubleAppliedMaskJoin1, doubleAppliedMaskJoin2
  )

def generateBinaries(appliedMasks):
  # variable names correspond to output variables in applyMasks()
  (sam1, sam2, damov1, damov2, damjo1, damjo2) = appliedMasks

  # generate thresholded images
  (_, sam1t) = cv.threshold(sam1, 0, 255, cv.THRESH_BINARY_INV)
  (_, sam1ti) = cv.threshold(sam1, 0, 255, cv.THRESH_BINARY_INV)
  (_, sam2t) = cv.threshold(sam2, 0, 255, cv.THRESH_BINARY)
  (_, sam2ti) = cv.threshold(sam2, 0, 255, cv.THRESH_BINARY_INV)

  (_, damov1t) = cv.threshold(damov1, 0, 255, cv.THRESH_BINARY)
  (_, damov2t) = cv.threshold(damov2, 0, 255, cv.THRESH_BINARY_INV)

  (_, damjo1t) = cv.threshold(damjo1, 0, 255, cv.THRESH_BINARY_INV)
  (_, damjo2t) = cv.threshold(damjo2, 0, 255, cv.THRESH_BINARY)

  # return differences in binary images
  return ((damov2t-sam2t), (sam1t-damov1t), (sam2ti-damjo2t))

这个示例图像中的结果很好，非常有用，尽管它看起来非常错误：请参见结果。

很容易得到这个示例图像更好的结果（例如，只返回一个或两个候选对象，其中包括足球的完美边界框），但是，在大量参数调整后，我在这个示例中使用的参数似乎产生了最好的整体回忆。

然而，我非常执着于某些照片，我将展示原始图像、二值A和B图像（基于原始图像中值模糊和内核7生成）和二值C图像（内核15）。目前，我的方法平均每张照片返回15个候选人，其中25%的照片至少包含一个完美的球框，大约75%的照片，至少包括一个部分正确的边界框（例如，边界框中有一个球，或者只是球本身的一部分）。

原始图像二进制图像A

二值图像B二值图像C

（我只能发布多达8个链接）

我希望你们能给我一些关于如何进行的建议。

Answer 1

也可以使用blackhat和tophat形态学操作符在白色部分中查找球的嵌套黑色部分。它将比阈值更加健壮。

Answer 2

如何做到这一点有很多可能性。也许使用神经网络是一个很好的选择，但是你仍然需要理解和训练其中一个来完成你的任务。

您可以使用阈值和高斯模糊，作为一个建议，我可以添加使用归一化互相关进行模板匹配。基本上，您需要一个模板（在您的情况下，是一个球的图像，或者更好，是一组大小不同的图像，因为球的大小可能根据位置而有所不同）。

然后在图像上迭代并检查模板是否匹配。当然，这对有遮挡的图像不起作用，但它可能有助于获得一些候选图像。

有关上述过程的更多详细信息，请参阅本文(https://ieeexplore.ieee.org/document/5375779)或者这里的幻灯片(http://www.cse.psu.edu/~rtc12/CSE486/讲师07。pdf）。

我写了一小段代码来向您展示这个想法。只是从图像中截取了球（所以我作弊了，但这只是为了展示想法）。它还只使用球和图像之间的差异，而更复杂的度量（如NCC）会更好，但如上所述，就是一个例子。

import matplotlib.pyplot as plt
import numpy as np
import pdb
import cv2

def rgb2gray(rgb):

    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b

    return gray

if __name__ == "__main__":

    ball = plt.imread('ball.jpg');
    ball = rgb2gray(ball);
    findtheballcol = plt.imread('findtheball.jpg');
    findtheball = rgb2gray(findtheballcol)
    matching_img = np.zeros((findtheball.shape[0], findtheball.shape[1]));

    #METHOD 1
    width = ball.shape[1]
    height = ball.shape[0]
    for i in range(ball.shape[0], findtheball.shape[0]-ball.shape[0]):
        for j in range(ball.shape[1], findtheball.shape[1]-ball.shape[1]):


            # here use NCC or something better
            matching_score = np.abs(ball - findtheball[i:i+ball.shape[0], j:j+ball.shape[1]]);
            # inverting so that max is what we are looking for
            matching_img[i,j] = 1 / np.sum(matching_score);


    plt.subplot(221);
    plt.imshow(findtheball); 
    plt.title('Image')
    plt.subplot(222);
    plt.imshow(matching_img, cmap='jet');
    plt.title('Matching Score')
    plt.subplot(223);
    #pick a threshold
    threshold_val = np.mean(matching_img) * 2; #np.max(matching_img - (np.mean(matching_img)))
    found_at = np.where(matching_img > threshold_val)
    show_match = np.zeros_like(findtheball)
    for l in range(len(found_at[0])):
        yb = round(found_at[0][l]-height/2).astype(int)
        yt = round(found_at[0][l]+height/2).astype(int)
        xl = round(found_at[1][l]-width/2).astype(int)
        xr = round(found_at[1][l]+width/2).astype(int)
        show_match[yb: yt, xl: xr] = 1;
    plt.imshow(show_match)
    plt.title('Candidates')
    plt.subplot(224)
    # higher threshold
    threshold_val = np.mean(matching_img) * 3; #np.max(matching_img - (np.mean(matching_img)))
    found_at = np.where(matching_img > threshold_val)
    show_match = np.zeros_like(findtheball)
    for l in range(len(found_at[0])):
        yb = round(found_at[0][l]-height/2).astype(int)
        yt = round(found_at[0][l]+height/2).astype(int)
        xl = round(found_at[1][l]-width/2).astype(int)
        xr = round(found_at[1][l]+width/2).astype(int)
        show_match[yb: yt, xl: xr] = 1;
    plt.imshow(show_match)
    plt.title('Best Candidate')
    plt.show()

玩得高兴