Question

我是Image Processing的新手，并且遇到了问题。我有这张图片：

我的目标是将其变成一个矩阵，如果单元格内有红色，则为1;如果没有，则为0。

所以这将是

10000000000
10001000000
10001000000
10001000000
11111111111
10000000101
10111111101
etc...

所以我有我的代码，它可以提取轮廓并使用approxPolyDP来确定4个角边的（x，y）坐标。

现在我需要弄清楚如何确定某个颜色（红色）是否在每个轮廓内。

以下是我的一些代码：希望有人可以提供帮助！

def extract_cells(grid):
    #convert to gray
    image_gray = cv2.cvtColor(grid, cv2.COLOR_BGR2GRAY)
    #creates a binary image from the gray scale image to use as input for findContours()
    #thresh = cv2.adaptiveThreshold(image_gray,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY_INV,11,15)

    #Find countors
    tempimg, contours, hierarchy = cv2.findContours(image_gray, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

    #draw all countours
    count = 0
    max_size = 0
    matrix = [] 
    new_contours = []
    grid_contour = 0
    grid_contour_row = None
    grid_contour_column = None
    for each in enumerate(contours):

        #used to find the midpoint of each cell
        M = cv2.moments(contours[count])
        row = int(M['m10']/M['m00'])
        column = int(M['m01']/M['m00'])

        #find biggest box (this is the grid itself, so needs to be removed since it is not a cell)
        size = cv2.contourArea(contours[count])
        if (size > max_size):
            new_contours.append(contours[grid_contour])
            #put a marker in each cell for testing
            #if (grid_contour_row != None and grid_contour_column != None):
                #cv2.putText(grid, "0", (grid_contour_row, grid_contour_column), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))
            grid_contour = count
            grid_contour_row = row
            grid_contour_column = column
        else:
            new_contours.append(contours[count])
            #put a marker in each cell for testing
            #cv2.putText(grid, "0", (row, column), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))

        #matrix = create_matrix(matrix,count)
        count += 1

    #draw white lines showing contours
    cv2.drawContours(grid, new_contours, -1, (255,255,255))

    #approx contains x,y coordinates for the 4 corners of the cell
    approx = cv2.approxPolyDP(contours[0],0.01*cv2.arcLength(contours[0],True),True)

    cv2.imshow("test", grid)
    cv2.waitKey(0)
    return new_contours, approx


def identify_colors(image, *colors):
    colorlist = []
    #Add RGB values for each color specified when the function was called
    #to the list colorlist

    if "blue" in colors:
        colorlist.append(([115,0,0], [255,100,100]))
    if "white" in colors:
        colorlist.append(([215, 215, 215], [255, 255, 255]))
    if "red" in colors:
        colorlist.append(([0,0,100], [100,100,255]))
    if "green" in colors:
        colorlist.append(([0,115,0], [100,255,100]))

    #loop over the colorlist
    for (lower, upper) in colorlist:
        # create NumPy arrays from the colorlist
        lower = np.array(lower, dtype = "uint8")
        upper = np.array(upper, dtype = "uint8")

        #econverts image to b/w with white being anything in the BGR value range
        mask = cv2.inRange(image, lower, upper)
        #converts that specified range back to its orginal color
        output = cv2.bitwise_and(image, image, mask = mask)

        #show the photos side by side
        #cv2.imshow("images", np.hstack([image, output]))
        #cv2.waitKey(0)

    return output

Answer 1

如果您使用scipy.ndimage.label()：

，这会简单得多

from scipy import ndimage
import cv2
import numpy as np
import pandas as pd

img = cv2.imread("image.png")

blue = np.array([200, 70, 60])
red = np.array([30, 20, 220])

isblue = cv2.inRange(img, blue, blue+20)
isred = cv2.inRange(img, red, red+20) > 0

labels, count = ndimage.label(~isblue)

loc = np.where(labels >= 2) #label 1 is the border

# to get the location, we need to sort the block along yaxis and xaxis
df = pd.DataFrame({"y":loc[0], "x":loc[1], "label":labels[loc], "isred":isred[loc]})

grid = df.groupby("label").mean().sort_values("y")

def f(df):
    return df.sort_values("x").reset_index(drop=True)
res = grid.groupby((grid.y.diff().fillna(0) > 10).cumsum()).apply(f)

print((res.isred.unstack(1) > 0).astype(np.uint8))

输出：

    0   1   2   3   4   5   6   7   8   9   10
y                                             
0    1   0   0   0   0   0   0   0   0   0   0
1    1   0   0   0   1   0   0   0   0   0   0
2    1   0   0   0   1   0   0   0   0   0   0
3    1   0   0   0   1   0   0   0   0   0   0
4    1   1   1   1   1   1   1   1   1   1   1
5    1   0   0   0   0   0   0   1   1   1   1
6    1   0   1   1   1   1   1   1   1   0   1
7    0   0   0   0   0   0   0   0   0   0   1
8    0   0   0   0   0   0   0   0   0   0   1
9    0   0   0   0   0   0   0   0   0   0   1
10   0   0   0   0   0   0   0   0   0   0   1

Answer 2

您可以按以下步骤操作：

为红色和蓝色创建遮罩
从蓝色面具，创建四个每个小方块的轮廓
看，红色像素在一个小方块中

结果如下所示：

附有评论的代码。

我刚刚看到你需要从列表中生成打印的矩阵，对于列表包含0或1的每个正方形以及该正方形的质心的x / y坐标。不幸的是，轮廓并没有按照正常情况排序。由于形状不规则的小顺序，所以你仍然需要自己做一些坐标排序，对不起。

如果你想避免这种情况，你也可以通过使用从某个常规网格生成的种子进行泛洪填充来生成mask2，并循环遍历该网格。

import cv2
import numpy as np
img = cv2.imread('image.png')


# Define range of blue color 
lower_limit = np.array([204,72,63])
upper_limit = np.array([204,72,63])

# Generate mask for the blue pixels 
blue_colour_mask = cv2.inRange(img, lower_limit, upper_limit)

# Define range of red color 
lower_limit = np.array([36,28,237])
upper_limit = np.array([36,28,237])

# Generate mask for the red  pixels 
red_colour_mask = cv2.inRange(img, lower_limit, upper_limit)


# Remove outer black area
flooded = img.copy()
x = 5
y = 5
flooded = blue_colour_mask.copy()
h, w = blue_colour_mask.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
mask[:] = 0
cv2.floodFill(flooded,mask,(x,y),(255,)*3, (40,)*3, (40,)*3, 4 )


# Loop through each single small rectange (contour # from 1 to 121, 0 ist image border)
_, contours, hierarchy = cv2.findContours( flooded.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
h, w = img.shape[:2]

result= np.zeros((h, w, 3), np.uint8)
result[:] = 0

mask2 = np.zeros((h, w), np.uint8)
list =[]

for i in range(1,122):
    mask2[:] = 0
    cv2.drawContours( mask2, contours, i, (255,255,255), cv2.FILLED)
    mask3= cv2.bitwise_and(mask2, red_colour_mask)
    pixnumber= cv2.countNonZero(mask3)

    if pixnumber == 0:
        cv2.drawContours( result, contours, i, (255,255,255), cv2.FILLED)
        moments = cv2.moments(contours[i])
        cx = int(moments['m10']/moments['m00'])
        cy = int(moments['m01']/moments['m00'])
        print 0, i, cx, cy
        list.append([0,cx, cy])
    else:
        cv2.drawContours( result, contours, i, (0,0,255), cv2.FILLED)
        moments = cv2.moments(contours[i])
        cx = int(moments['m10']/moments['m00'])
        cy = int(moments['m01']/moments['m00'])     
        print 1, i, cx, cy
        list.append([0,cx, cy])

cv2.imshow('Result',result)

cv2.waitKey(0)

print list


cv2.imshow('image',img)
cv2.imshow('Blue pixel mask',blue_colour_mask)
cv2.imshow('Red pixel mask',red_colour_mask)
cv2.imshow('Result',result)

cv2.waitKey(0)

Answer 3

import cv2
import numpy as np


def centroid(contour):
    x,y,w,h = cv2.boundingRect(contour)
    return (y+h/2.0, x+w/2.0)

def contains_red(red_mask, tile):
    tile_area = np.zeros_like(red_mask)
    cv2.drawContours(tile_area, [tile[1]], 0, 255, -1)
    red_tile_area = cv2.bitwise_and(tile_area, red_mask)
    return (cv2.countNonZero(red_tile_area) > 0)

def get_transform(grid_size, grid_contour):
    x,y,w,h = cv2.boundingRect(grid_contour)
    tile_w = float(w) / (grid_size[0])
    tile_h = float(h)/ (grid_size[1])
    return ((-y - tile_h/2, -x - tile_w/2), (1/tile_h, 1/tile_w))


img = cv2.imread("input.png")

hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h, s, v = cv2.split(hsv)

cv2.imwrite("out_1.png", np.hstack([h, s, v]))

# Saturation mask to get rid of black
s_mask = cv2.threshold(s, 10, 255, cv2.THRESH_BINARY)[1]

# Pick out blue area
blue_range = [110, 130]
blue_mask = cv2.inRange(h, blue_range[0], blue_range[1])
blue_mask = cv2.bitwise_and(blue_mask, s_mask)


# Pick out blue area
red_range = [[170, 180], [0,10]]
red_mask = cv2.bitwise_or(
    cv2.inRange(h, red_range[0][0], red_range[0][1])
    , cv2.inRange(h, red_range[1][0], red_range[1][1]))
red_mask = cv2.bitwise_and(red_mask, s_mask)

cv2.imwrite("out_2.png", np.hstack([s_mask, blue_mask, red_mask]))


kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
# Remove noise
blue_mask = cv2.morphologyEx(blue_mask, cv2.MORPH_OPEN, kernel)
# Fill any small holes
blue_mask = cv2.morphologyEx(blue_mask, cv2.MORPH_CLOSE, kernel)


# Find outer contour, and fill area outside
cnt_grid = cv2.findContours(blue_mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
assert(len(cnt_grid) == 1)
grid_area = np.zeros_like(blue_mask)
cv2.drawContours(grid_area, cnt_grid, 0, 255, -1)
grid_tiles = cv2.bitwise_and(cv2.bitwise_not(blue_mask), grid_area)

cv2.imwrite("out_3.png", np.hstack([blue_mask, grid_area, grid_tiles]))

# Find contours of our tiles
cnt_tiles = cv2.findContours(grid_tiles.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]

# Find scaling parameters
offset, scale = get_transform((11, 11), cnt_grid[0])

tiles = [[centroid(contour), contour, False] for contour in cnt_tiles]
for tile in tiles:
    # Rescale centroid
    tile[0] = (
        int(round((tile[0][0] + offset[0]) * scale[0]))
        , int(round((tile[0][1] + offset[1]) * scale[1]))
    )
    tile[2] = contains_red(red_mask, tile)

# Sort the tiles
tiles = sorted(tiles, key=lambda x: x[0], reverse=False)

# Extract the results
result = np.array([int(t[2]) for t in tiles])

print result.reshape(11,11)

我们首先将图像分割为HSV色彩空间。

Hue，Saturation，Value channels：

由于黑色可以结束任何色调，我们应该忽略不饱和像素。

然后我们可以使用范围，按位和饱和蒙版来提取蓝色和红色蒙版。

饱和度蒙版，蓝色和红色蒙版：

我们应用形态开启和关闭以消除噪音。

我们通过获得外部轮廓来识别网格本身的区域。

然后我们通过在倒置图像上获得外部轮廓来识别图块区域。

蓝色遮罩，网格区域遮罩，平铺遮罩：

接下来我们计算瓷砖的质心。

我们假设图块网格大小是常量或由用户输入。基于网格边界框坐标，我们可以确定缩放和偏移，以将我们的质心重新采样到0..10。

然后我们可以按质心坐标对切片进行排序，然后重新整形以获得结果。

结果：

[[1 0 0 0 0 0 0 0 0 0 0]
 [1 0 0 0 1 0 0 0 0 0 0]
 [1 0 0 0 1 0 0 0 0 0 0]
 [1 0 0 0 1 0 0 0 0 0 0]
 [1 1 1 1 1 1 1 1 1 1 1]
 [1 0 0 0 0 0 0 0 1 1 1]
 [1 0 1 1 1 1 1 1 1 0 1]
 [0 0 0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0 0 1]]

确定颜色是否在轮廓OpenCV中

3 个答案: