尋找具有最大表面積的邊界盒輪廓，不包括交叉區域

我是如何嘗試并失敗地解決這個問題的。

方法一.

遍歷每一個點，找到x和y的最小和最大值。

然后使用這些坐標裁剪成一個多邊形。

問題是，在一個示例影像上的演算法將洗掉影像的頂部部分，但沒有必要，因為我們 "錯過了 "頂部的左和右框。

方法二。

嘗試一次只選擇裁剪一邊，因為在我的資料集中，通常要排除的東西都在一邊。例如，移除頂部的100px

當圖片的兩邊都有盒子的時候，這種方法很快就失敗了，比如左邊和右邊

uj5u.com熱心網友回復：

這里有一個潛在的解決方案來尋找具有最大表面積的邊界盒輪廓。我們有兩個要求：

1. 最大的邊界框沒有與任何其他框相交
。
2. 最大的邊界盒不在另一個盒子里面
。

本質上，我們可以將這兩個要求改寫為：

1. 給定C1和C2，確定C1和C2是否相交
。
2. 給定C1和C2，檢查C2中是否有一個來自C1的點
。

為了解決#1，我們可以創建一個contour_intersect函式，該函式使用位數AND操作，并使用

答案：

Contour #0是最大的。

接下來我們添加兩條額外的輪廓線。3號輪廓線將代表相交情況，4號輪廓線將代表內部輪廓線情況。

答案：

Contour #0 has failed test。
Contour #1 has failed test。
輪廓線#2是最大的。

為了解決這個問題，我們先找到等高線，然后用等高線面積從大到小排序。接下來，我們將這個輪廓與所有其他輪廓進行比較，并檢查這兩種情況。如果任何一種情況都失敗了，我們就拋棄當前的輪廓，轉到下一個最大的輪廓。第一個通過所有其他輪廓的測驗的輪廓就是我們最大的邊界盒輪廓。通常情況下，0號輪廓是我們最大的輪廓，但是它沒有通過相交測驗。然后我們轉到1號輪廓，但它沒有通過內部測驗。因此，剩下的最后一個通過兩項測驗的輪廓是2號輪廓。

import cv2
import numpy as np

# 檢查C1和C2是否相交[/span]。
def contour_intersect(original_image, contour1, contour2) 。
    # 兩個獨立的輪廓試圖檢查相交點。
    contours = [contour1, contour2].

    # 創建充滿零的影像，其大小與原始影像相同。
    blank = np.zeros(original_image.shape[0:2] )

    # 將每個輪廓復制到自己的影像中，并填充'1'。
    image1 = cv2.drawContours(blank.copy(), contours, 0, 1)
    image2 = cv2.drawContours(blank.copy(), contours, 1, 1)

    # 在兩張圖片上使用邏輯AND操作。
    # 由于這兩幅影像已被位元化并應用于它，
    # 在有交集的地方應該有一個'1'或'True'。
    # 而在沒有相交的地方應該有一個'0'或'False'。
    intersection = np.logical_and(image1, image2)

    # 檢查是否有一個'1'在交叉點。
    return intersection.any()

# 檢查C1是否在C2中。
def contour_inside(contour1, contour2) 。
    # 查找C1的中心點。
    M = cv2.ments(contour1)
    cx = int(M['m10']/M['m00'] )
    cy = int(M['m01']/M['m00'] )

    inside = cv2.pointPolygonTest(contour2, (cx, cy), False)

    if inside == 0 or inside == -1:
        return False:return
    elif inside == 1:
        return True: return True: 1.

#加載影像，轉換為灰度，大津的閾值。
image = cv2.imread('1.png')
Original = image.copy()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(grey, 0, 255, cv2.THRESH_BINARY_INV   cv2.THRESH_OTSU) [1]

# 查找等高線，按等高線面積從大到小排序。
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if len(cnts) == 2 else cnts[1]
sorted_cnts = sorted(cnts, key=lambda x: cv2.contourArea(x), reverse=True)

# "交叉 "和 "內部 "輪廓線。
# 添加兩個輪廓線來測驗。
# --------------------------------
intersect_contour = np. array([[230, 93]], [[230, 187]], [[326, 187]], [[326, 93]])
sorted_cnts.append(intersect_contour)
cv2.drawContours(original, [intersect_contour], -1, (36,255,12), 3)

inside_contour = np. array([[380, 32]], [[380, 229]], [[740, 229]], [[740, 32]])
sorted_cnts.append(inner_contour)
cv2.drawContours(original, [inside_contour], -1, (36,255,12), 3)
# --------------------------------

# 找出每個輪廓的中心點并標注輪廓編號。
for count, c in enumerate(sorted_cnts):
    M = cv2.ments(c)
    cx = int(M['m10']/M['m00'] )
    cy = int(M['m01']/M['m00'] )
    cv2.putText(original, str(count), (cx-5, cy 5), cv2.FONT_HERSHEY_SIMPLEX, 0。 7, (246,255, 12), 3)

# 查找最大的邊界盒輪廓線。
largest_contour_name = ""/span>
largest_contour = ""/span>
contours_length = len(sorted_cnts)
for i1 in range（contours_length）。
    found = Truefor i2 in range（i1   1, contours_length）。
        c1 = sorted_cnts[i1] 。
        c2 = sorted_cnts[i2] 。
        
        # 測驗交叉點和 "內部 "輪廓。
        if contour_intersect(original, c1, c2) or contour_inside(c1, c2) 。
            print('contour #{} has failed test'.format(i1)
            found = False。
            繼續[/span
    if found:
        largest_contour_name = i1
        largest_contour = sorted_cnts[i1] 。
        break
print('Contour #{} is the largest'.format(maximum_contour_name)
print(maximum_contour)

# 顯示'thresh', thresh)
cv2.imshow('image', image)
cv2.imshow('original', original)
cv2.waitKey()

注意：假設你有一個來自cv2.findContours()的等高線陣列，其格式就像這個例子：

cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if len(cnts) == 2 else cnts[1]
sorted_cnts = sorted(cnts, key=lambda x: cv2.contourArea(x), reverse=True)
for c in sorted_cnts:
    print(c)
    print(type(c))
    x,y,w,h = cv2.boundingRect(c)
    print((x,y,w,h))

輸出

[[230 93] ]

 [[230 187 ]]

 [[326 187 ]]

 [[326 93]]。
<class 'numpy.ndarray'>
(230，93，97，95)

性能說明：相交檢查函式在性能方面受到了影響，因為它創建了三個輸入影像的副本來繪制輪廓，當涉及到更多的輪廓或更大的輸入影像尺寸時，執行時間可能會更慢。我將把這個優化步驟留給你！

uj5u.com熱心網友回復：

考慮一個完整的重角（最初是整個圖片），并拿走一個被排除的盒子。你將得到2x2x2x2=16個可能的矩形磁區，例如這個。

 ┌────────────────────────┐
  │ │
  │ │
  ├───────┬───────┬────────┤
  │ │ exc │ │
  │ │ lude │ │ │
  │ ├───────┴────────┤
  │ │ │
  │ │ │
  └───────┴────────────────┘

對于細分的每一個盒子，拿走下一個被排除的盒子。 這樣做了N次，最后一步取最大的盒子。

uj5u.com熱心網友回復：

你可以使用

uj5u.com熱心網友回復：

假設：你想要你的陣列中符合你的規則的最大的盒子，而且它不是符合規則的最大的新邊界盒。

這是偽代碼，你仍然需要填寫空白處

int largestBoxIndex = -1;
int largestBoxArea = -1;

for (i=0; i<allBoxes[] .length; i  )
{
    box CurrentBox = allBoxes[i];
    bool isComply = false;
    for (j=0; j<allBoxes[] .length; j  )
    {
        isComply = false;

        if(i==j) break;

        比較盒 = allBoxes[j] 。

        if (isIntersected(CurrentBox, ComparedBox)) break;

        if (isInside(CurrentBox, ComparedBox)) break。
        
        isComply = true。   
    }

    if(isComply)
        if(Area(allBoxes[i]) > largestBoxArea)
        {
            largestBoxArea = Area(allBoxes[i]):
            largestBoxIndex =i;
        }

}

if(maximumBoxIndex != -1)
    largestBoxIndex;//這個是最大的盒子。

uj5u.com熱心網友回復：

問題的簡單數學解決方案

請注意，這些矩形的格式是。[x, y, width, height]。 其中，(x, y)是矩形左上角的坐標，而width & height分別是矩形的寬度和高度。你必須先將你的坐標轉換為這種格式。

在這5個坐標中，有3個是相交的。

現在我們要做的是逐一遍歷這些矩形，對于每個矩形，逐一找到這個矩形與其他矩形的交點。如果發現任何一個矩形與其他任何一個矩形相交，那么我們將為這兩個矩形設定flag值為0。如果發現一個矩形沒有與任何其他矩形相交，那么它的flag值將被設定為1。(默認的標志值是-1)。最后，我們將在標志值為1的矩形中找到面積最大的矩形。

讓我們來看看尋找兩個矩形的交集面積的代碼：

# Rect : [x, y, w, h]/span> def Intersection(Rect1, Rect2) 。 x = max(Rect1[0], Rect2[0] ) y = max(Rect1[1], Rect2[1] ) w = min(Rect1[0] Rect1[2] 。Rect2[0] Rect2[2]) - x h = min(Rect1[1] Rect1[3] 。Rect2[1] Rect2[3]) - y if w < 0 or h < 0: return None: 0. return [x, y, w, h] 。

如果這些矩形之間沒有相交的區域，這個函式將回傳None，或者它將回傳相交矩形的坐標（對于當前問題忽略這個值。這可能對其他問題有幫助）。

現在，讓我們來看看這個演算法。

n = len(rects)

# -1 : 未確定。
# 0 : 與某些人相交。
# 1 : 沒有相交。
flag = [-1]*n

for i in range（n）。
    if flag[i] == 0:
        繼續：繼續。

    isIntersecting = False: continue
    for j in range（n）。
        if i == j or flag[j] == 1:
            繼續。
        
        Int_Rect = Intersection(rects[i], rects[j])
        if Int_Rect is not None:
            isIntersecting = True True None.
            flag[j] = 0: isIntersecting = True
            flag[i] =0
            break
    
    if isIntersecting == False:
        flag[i] = 1: flag[i] = 1.

# 找到沒有任何交集的最大面積矩形。
maxRect = None
maxArea = -1

for i in range（n）。
    if flag[i] == 1:
        if rects[i][2] * rects[i][3] > maxArea。
            maxRect = rects[i]
            maxArea = rects[i][2] * rects[i][3]

print(maxRect)

注意：將 "排除區域 "的矩形坐標添加到rects串列中，并將其flag值指定為0，以避免它們被選為最大面積矩形。

這個解決方案不涉及任何影像，所以它將是最快的演算法，除非它被優化。

uj5u.com熱心網友回復：

尋找numpy陣列中最大的正方形

也許這個會有幫助？如果你知道整個區域的大小，你可以計算出numpy陣列中最大的方框。如果你把所有給定的方塊都設為1，而整個面積為0，你需要找到唯一的、不是1的最大面積。

標籤：

上一篇：帶有FILE_ATTRIBUTE_OFFLINE動態動詞的快捷選單

下一篇：如何通過IDE（IntellliJ/Eclipse）呼叫Karate的主類？