如何检测与背景融合的对象？

Question

我是一个初学者，我正在尝试将轮廓应用于左侧的白色遥控器，该遥控器与背景共享相同的颜色。

a = cv2.imread(file_name)
imgGray = cv2.cvtColor(a,cv2.COLOR_BGR2GRAY)

imgGray = cv2.GaussianBlur(imgGray,(11,11),20)

k5 = np.array([[-1,-1,-1],[-1,9,-1],[-1,-1,-1]])
imgGray = cv2.filter2D(imgGray,-1,k5)

cv2.namedWindow("Control")
cv2.createTrackbar("blocksize","Control",33,1000,f)
cv2.createTrackbar("c","Control",3,100,f)
while True:
    strel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
    blocksize = cv2.getTrackbarPos("blocksize","Control")
    c = cv2.getTrackbarPos("c","Control")

    if blocksize%2==0:
        blocksize += 1
    thrash = cv2.adaptiveThreshold(imgGray,255,cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV,blockSize=blocksize,C=c)
    thrash1 = cv2.adaptiveThreshold(imgGray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,blockSize=blocksize,C=c)

    cv2.imshow("mean",thrash)
    cv2.imshow("gaussian",thrash1)
    #r,thrash = cv2.threshold(imgGray,150,255,cv2.THRESH_BINARY_INV)
    key = cv2.waitKey(1000)
    if key == 32 or iter == -1:
         break


edges = cv2.Canny(thrash,100,200)
cv2.imshow('sharpen',sharpen)
cv2.imshow('edges',edges)
cv2.imshow('grey ',imgGray)
cv2.imshow('thrash ',thrash)
cv2.waitKey(0)
circles = cv2.HoughCircles(imgGray,cv2.HOUGH_GRADIENT,1,60,param1=240,param2=50,minRadius=0,maxRadius=0)
contours,_ = cv2.findContours(thrash,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
putlabel(circles,a,contours)

这些是我尝试的东西，我还尝试了形态学操作，例如扩张，侵蚀，打开和关闭，但我仍然无法获得结果。

以下是我最好的结果，但是噪音太严重，遥控器没有完全概述。

Answer 1

我认为简单的图像处理无法隔离具有与背景相同颜色的对象。因此，我们必须切换到深度/机器学习。这个想法是使用u-2-net 删除图像的背景我们的前景中所有对象的面膜，然后在白色上hsv颜色阈值以隔离对象。

后的结果掩码，

这是通过U-2-NET运行它以删除背景位并隔离对象

现在我们可以使用传统的图像处理，因为我们可以区分前景和背景。接下来，我们的HSV颜色阈值具有较低/上颜色范围，以隔离白色，从而插入该面罩。您可以使用。

现在，我们只是执行一些形态操作，以清理任何噪音，查找轮廓并按最大的轮廓区域排序。最大轮廓将是我们所需的对象的假设。 这是结果

代码，我很想知道如何！

import cv2
import numpy as np

# Load image + mask, grayscale, Gaussian blur, Otsu's threshold
image = cv2.imread("1.jpg") # This is the original image
original = image.copy()
mask = cv2.imread("1.png") # This is the mask generated from U-2-Net
gray = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
bg_removed = cv2.bitwise_and(image, image, mask=thresh)

# HSV color thresholding
hsv = cv2.cvtColor(bg_removed, cv2.COLOR_BGR2HSV)
lower = np.array([0, 0, 0])
upper = np.array([179, 33, 255])
hsv_mask = cv2.inRange(hsv, lower, upper)
isolated = cv2.bitwise_and(bg_removed, bg_removed, mask=hsv_mask)
isolated = cv2.cvtColor(isolated, cv2.COLOR_BGR2GRAY)
isolated = cv2.threshold(isolated, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]

# Morph operations to remove small artifacts and noise
open_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
opening = cv2.morphologyEx(isolated, cv2.MORPH_OPEN, open_kernel, iterations=1)
close_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5,5))
close = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, close_kernel, iterations=1)

# Find contours and sort by largest contour area
cnts = cv2.findContours(close, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if len(cnts) == 2 else cnts[1]
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)
for c in cnts:
    cv2.drawContours(original, [c], -1, (36,255,12), 3)
    break

cv2.imshow("bg_removed", bg_removed)
cv2.imshow("hsv_mask", hsv_mask)
cv2.imshow('isolated', isolated)
cv2.imshow('original', original)
cv2.waitKey()

如果有人使用简单的图像处理而不是深度/机器学习，那么

Answer 2

我想到了一种纯粹的图像处理方法。但是结果不如@nathancy

理论

TLDR所描绘的结果准确。我使用的是高斯（Dog）的差异，这是一个2级边缘检测器。

• 获取灰度图像。
• 对其进行两个不同的模糊操作。
• 减去模糊的图像

模糊操作通常充当高频的抑制剂。通过减去两个不同模糊操作的结果，我们获得了一个带通滤波器。我想从“从另一个中减去一个模糊的图像，保存在两个模糊图像中保存的频率范围之间的空间信息”，

我写了一个简单的函数，返回两个模糊图像的差异：

def dog(img, k1, s1, k2, s2):
    b1 = cv2.GaussianBlur(img,(k1, k1), s1)
    b2 = cv2.GaussianBlur(img,(k2, k2), s2)
    return b1 - b2

方法

• 获得GRAYSCALE IMAGE
• 表演高斯表演高斯 模糊
• 减去模糊图像
• 应用OTSU阈值，
• 具有不同内核大小和sigma值的
• 根据其范围

注意：范围是轮廓的特性，这是<的范围，这是<范围的特性，是<强>轮廓面积与其相应的边界矩形区域。 从此处获取

代码＆amp;结果

img = cv2.imread('path_to_image', cv2.IMREAD_UNCHANGED)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Function to perform Difference of Gaussians
def difference_of_Gaussians(img, k1, s1, k2, s2):
    b1 = cv2.GaussianBlur(img,(k1, k1), s1)
    b2 = cv2.GaussianBlur(img,(k2, k2), s2)
    return b1 - b2

DoG_img = difference_of_Gaussians(gray, 7, 7, 17, 13)

如您所见，它可以用作边缘检测器。您可以更改内核大小（ k1，k2 ）和sigma值（ s1，s2 ）

# Applying Otsu Threshold and finding contours
th = cv2.threshold(DoG_img ,127,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]
contours, hierarchy = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

# Create copy of original image
img1 = img.copy()

# for each contour above certain area and extent, draw minimum bounding box  
for c in contours:
    area = cv2.contourArea(c)
    if area > 1500:
        x,y,w,h = cv2.boundingRect(c)
        extent = int(area)/(w*h)                
        if extent > 0.6:
            rect = cv2.minAreaRect(c)
            box = cv2.boxPoints(rect)
            box = np.int0(box)
            cv2.drawContours(img1,[box],0,(0,255,0),4)

您可以看到，结果不是完美的。在边缘检测过程（高斯差异）期间，还捕获了物体的阴影。您可以尝试更改参数以检查结果是否会变得更好。