問題描述

我無法區分以下兩個輪廓.cv2.contourArea 為兩者提供相同的值.Python中有什么函數可以區分它們嗎?

為了區分填充輪廓和未填充輪廓，可以在查找輪廓時使用輪廓層次結構

最外面的七個輪廓都是那些沒有父輪廓的輪廓，即那些在其 hierarchy 條目的第四個字段中具有 -1 值的輪廓.根"之一之下的每個子節點.表示最外輪廓內的輪廓.請注意等高線 13 和 14 如何位于圖中的等高線 12 下方.這兩個輪廓代表最里面的輪廓，可能是其中一個點中的噪聲或一些丟失的油漆.一旦我們了解了輪廓是如何排列成層次結構的，我們就可以執行更復雜的任務，例如除了計算圖像中對象的數量之外，還計算形狀中輪廓的數量.

回到您的問題，我們可以使用層次結構來區分內輪廓和外輪廓，以確定輪廓是填充還是未填充.我們可以將填充輪廓定義為沒有子元素的輪廓，而將未填充輪廓定義為至少一個子元素.因此，使用此輸入圖像的屏幕截圖(刪除框):

結果

代碼

導入 cv2將 numpy 導入為 np# 加載圖片，灰度，Otsu的閾值圖像 = cv2.imread('1.png')灰色 = cv2.cvtColor(圖像，cv2.COLOR_BGR2GRAY)thresh = cv2.threshold(灰色, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]# 使用輪廓層次過濾cnts，層次結構 = cv2.findContours(thresh，cv2.RETR_TREE，cv2.CHAIN_APPROX_SIMPLE)層次結構=層次結構[0]對于 zip 中的組件(cnts，層次結構):currentContour = 組件[0]currentHierarchy = 組件[1]x,y,w,h = cv2.boundingRect(currentContour)# 有內部輪廓，這意味著它是未填充的如果當前層次結構 [3] >0:cv2.putText(圖像，'未填充'，(x，y-10)，cv2.FONT_HERSHEY_SIMPLEX，0.7，(36,255,12)，2)# 沒有孩子，這意味著它已被填滿elif currentHierarchy[2] == -1:cv2.putText(image, 'Filled', (x,y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (36,255,12), 2)cv2.imshow('圖像', 圖像)cv2.waitKey()

I am unable to differentiate the below two contours. cv2.contourArea is giving the same value for both. Is there any function to distinguish them in Python?

To distinguish between a filled contour and unfilled contour, you can use contour hierarchy when finding contours with cv2.findContours(). Specifically, you can select the contour retrieval mode to optionally return an output vector containing information about the image topology. There are the four possible modes:

• cv2.RETR_EXTERNAL - retrieves only the extreme outer contours (no hierarchy)
• cv2.RETR_LIST - retrieves all of the contours without establishing any hierarchical relationships
• cv2.RETR_CCOMP - retrieves all of the contours and organizes them into a two-level hierarchy. At the top level, there are external boundaries of the components. At the second level, there are boundaries of the holes. If there is another contour inside a hole of a connected component, it is still put at the top level
• cv2.RETR_TREE - retrieves all of the contours and reconstructs a full hierarchy of nested contours

Understanding contour hierarchies

So with this information, we can use cv2.RETR_CCOMP or cv2.RETR_TREE to return a hierarchy list. Take for example this image:

When we use the cv2.RETR_TREE parameter, the contours are arranged in a hierarchy, with the outermost contours for each object at the top. Moving down the hierarchy, each new level of contours represents the next innermost contour for each object. In the image above, the contours in the image are colored to represent the hierarchical structure of the returned contours data. The outermost contours are red, and they are at the top of the hierarchy. The next innermost contours -- the dice pips, in this case -- are green.

We can get that information about the contour hierarchies via the hierarchy array from the cv2.findContours function call. Suppose we call the function like this:

(_, contours, hierarchy) = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

The third return value, saved in the hierarchy variable in this code, is a three-dimensional NumPy array, with one row, X columns, and a "depth" of 4. The X columns correspond to the number of contours found by the function. The cv2.RETR_TREE parameter causes the function to find the internal contours as well as the outermost contours for each object. Column zero corresponds to the first contour, column one the second, and so on.

Each of the columns has a four-element array of integers, representing indices of other contours, according to this scheme:

[next, previous, first child, parent]

The next index refers to the next contour in this contour's hierarchy level, while the previous index refers to the previous contour in this contour's hierarchy level. The first child index refers to the first contour that is contained inside this contour. The parent index refers to the contour containing this contour. In all cases, an value of -1 indicates that there is no next, previous, first child, or parent contour, as appropriate. For a more concrete example, here are some example hierarchy values. The values are in square brackets, and the indices of the contours precede each entry. If you printed out the hierarchy array you will get something like this

0:  [ 6 -1  1 -1]   18: [19 -1 -1 17]
1:  [ 2 -1 -1  0]   19: [20 18 -1 17]
2:  [ 3  1 -1  0]   20: [21 19 -1 17]
3:  [ 4  2 -1  0]   21: [22 20 -1 17]
4:  [ 5  3 -1  0]   22: [-1 21 -1 17]
5:  [-1  4 -1  0]   23: [27 17 24 -1]
6:  [11  0  7 -1]   24: [25 -1 -1 23]
7:  [ 8 -1 -1  6]   25: [26 24 -1 23]
8:  [ 9  7 -1  6]   26: [-1 25 -1 23]
9:  [10  8 -1  6]   27: [32 23 28 -1]
10: [-1  9 -1  6]   28: [29 -1 -1 27]
11: [17  6 12 -1]   29: [30 28 -1 27]
12: [15 -1 13 11]   30: [31 29 -1 27]
13: [14 -1 -1 12]   31: [-1 30 -1 27]
14: [-1 13 -1 12]   32: [-1 27 33 -1]
15: [16 12 -1 11]   33: [34 -1 -1 32]
16: [-1 15 -1 11]   34: [35 33 -1 32]
17: [23 11 18 -1]   35: [-1 34 -1 32]

The entry for the first contour is [6, -1, 1, -1]. This represents the first of the outermost contours; note that there is no particular order for the contours, e.g., they are not stored left to right by default. The entry tells us that the next dice outline is the contour with index six, that there is no previous contour in the list, that the first contour inside this one has index one, and that there is no parent for this contour (no contour containing this one). We can visualize the information in the hierarchy array as seven trees, one for each of the dice in the image.

The seven outermost contours are all those that have no parent, i.e., those with an value of -1 in the fourth field of their hierarchy entry. Each of the child nodes beneath one of the "roots" represents a contour inside the outermost contour. Note how contours 13 and 14 are beneath contour 12 in the diagram. These two contours represent the innermost contours, perhaps noise or some lost paint in one of the pips. Once we understand how contours are arranged into a hierarchy, we can perform more sophisticated tasks, such as counting the number of contours within a shape in addition to the number of objects in an image.

Going back to your question, we can use hierarchy to distinguish between inner and outer contours to determine if a contour is filled or unfilled. We can define a filled contour as a contour with no child whereas a unfilled contour as at least one child. So with this screenshot of your input image (removed the box):

Result

Code

import cv2
import numpy as np

# Load image, grayscale, Otsu's threshold
image = cv2.imread('1.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]

# Filter using contour hierarchy
cnts, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
hierarchy = hierarchy[0]
for component in zip(cnts, hierarchy):
    currentContour = component[0]
    currentHierarchy = component[1]
    x,y,w,h = cv2.boundingRect(currentContour)
    # Has inner contours which means it is unfilled
    if currentHierarchy[3] > 0:
        cv2.putText(image, 'Unfilled', (x,y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (36,255,12), 2)
    # No child which means it is filled
    elif currentHierarchy[2] == -1:
        cv2.putText(image, 'Filled', (x,y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (36,255,12), 2)

cv2.imshow('image', image)
cv2.waitKey()

這篇關于如何區分 OpenCV 中的實心圓/輪廓和空心圓/輪廓?的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！