【PYTHON】使用OpenCV python從手繪邏輯閘圖中生成 bool(boolean) 表示式

輸入手繪邏輯閘圖


我使用YOLO來訓練和識別帶有標籤(字母)的7種不同的邏輯閘。
檢測輸入影象中的邏輯閘和標籤。


在這裡，我得到了一個包含每個矩形的陣列列表(框)。每個列表包含以下每個詳細資訊
依次按矩形
•矩形標籤
•矩形左上角的x，y座標
•矩形右下角的x，y座標

矩形框陣列。

boxs = [['AND'，(614，98)，(1146，429)]，['NOT'，(525，1765)，(1007，1983)]，['NAND'，(762，1188)， (1209，
1528)]，['NOR'，(1323、272)，(1884、682)]，['OR'，(575、599)，(1225、985)]，['XOR'，(1393、1368) ，(2177，
1842)]，['XNOR'，(2136、859)，(2762、1231)]，['A'，(34、50)，(321、224)]，['B'，(12、305) ，(344，487)]，['C'，(3，
581)，(391、779)]，['D'，(0、828)，(400、1060)]，['E'，(0、1143)，(354、1351)]，['F' ，(0、1418)，(313、1615)]，['G'，
(0，1753)，(301，1985)]，['OUTPUT'，(2810，940)，(3069，1184)]]

之後，我使用概率霍夫線變換來檢測標籤和邏輯閘之間的線。
為此，我引用了此連結[How to merge lines after HoughLinesP?。通過使用此連結，我減少到最少的行數，最後只得到35行。
檢測綠色的35條線



然後，我對這35條線進行分類，並將彼此接近的線分組。最終，我得到了14行。
最後的14行影象。



14行陣列。

final_line_points = [[[((87，1864)，(625，1869)]]，[[((623，1815)，(1354，1855)]，[(1343，1660)，(1770，1655)]，
[(1348，1656)，(1348，1869)]]，[[(102，971)，(531，945)]，[(518，835)，(892，825)]，[(521，830) ，(526，949)]]，
[[(105，1260)，(494，1254)]，[(487，1351)，(891，1340)]，[(489，1252)，(491，1356)]]，[[((107，1533) )，(526，
1510)]，[((516，1432)，(892，1410)]，[(521，1433)，(520，1514)]]，[[((111，432)，(519，396)]]，[[ 499，313)，(820，
299)]，[(503、310)，(506、402)]]，[[(123、157)，(496、150)]，[(493、144)，(498、247)]，[( 495，242)，(815，234)]]，
[[(170，692)，(509，687)]，[(504，771)，(888，764)]，[(505，685)，(508，775)]]，[[((936，264) )，(1229，261)]，[(1227，
257)，(1240、485)]，[(1234、481)，(1535、458)]]，[[(985、1361)，(1343、1347)]，[(1341、1344)，(1348， 1578)]，
[(1345，1575)，(1773，1571)]]，[[((991，796)，(1264，778)]]，[(1240，535)，(1544，520)]，[(1247，532) ，
(1254,783)]]，[[(1546，582)，(2156，489)]，[(2154，488)，(2148，1021)]]，[[(2153，1087)，(2164，1581) )]]，
[[((2444，1139)，(3017，1055)]]]

那麼，如何通過使用以上兩個陣列(框，final_line_points)獲得以下輸出？

解決辦法

您的專案看起來很酷，所以我花了一些時間尋找解決方案。我在下面的程式碼。程式碼的結果是:

OUTPUT[XNOR[NOR[AND[B, A], OR[D, C]], XOR[NOT[G], NAND[E, F]]]]

我假設，如果一個元素比另一個元素最左，則它是前一個塊。我還假設在您的那組線中，第一個是正確的...這使我可以將您的14條几行簡化為14條線。

boxes = [['AND', (614, 98), (1146, 429)], ['NOT', (525, 1765), (1007, 1983)], ['NAND', (762, 1188), (1209, 1528)],
         ['NOR', (1323, 272), (1884, 682)], ['OR', (575, 599), (1225, 985)], ['XOR', (1393, 1368), (2177, 1842)],
         ['XNOR', (2136, 859), (2762, 1231)], ['A', (34, 50), (321, 224)], ['B', (12, 305), (344, 487)],
         ['C', (3, 581), (391, 779)], ['D', (0, 828), (400, 1060)], ['E', (0, 1143), (354, 1351)],
         ['F', (0, 1418), (313, 1615)], ['G', (0, 1753), (301, 1985)], ['OUTPUT', (2810, 940), (3069, 1184)]]
final_line_points = [[[(87, 1864), (625, 1869)]],
                     [[(623, 1815), (1354, 1855)], [(1343, 1660), (1770, 1655)], [(1348, 1656), (1348, 1869)]],
                     [[(102, 971), (531, 945)], [(518, 835), (892, 825)], [(521, 830), (526, 949)]],
                     [[(105, 1260), (494, 1254)], [(487, 1351), (891, 1340)], [(489, 1252), (491, 1356)]],
                     [[(107, 1533), (526, 1510)], [(516, 1432), (892, 1410)], [(521, 1433), (520, 1514)]],
                     [[(111, 432), (519, 396)], [(499, 313), (820, 299)], [(503, 310), (506, 402)]],
                     [[(123, 157), (496, 150)], [(493, 144), (498, 247)], [(495, 242), (815, 234)]],
                     [[(170, 692), (509, 687)], [(504, 771), (888, 764)], [(505, 685), (508, 775)]],
                     [[(936, 264), (1229, 261)], [(1227, 257), (1240, 485)], [(1234, 481), (1535, 458)]],
                     [[(985, 1361), (1343, 1347)], [(1341, 1344), (1348, 1578)], [(1345, 1575), (1773, 1571)]],
                     [[(991, 796), (1264, 778)], [(1240, 535), (1544, 520)], [(1247, 532), (1254, 783)]],
                     [[(1546, 582), (2156, 489)], [(2154, 488), (2148, 1021)]], [[(2153, 1087), (2164, 1581)]],
                     [[(2444, 1139), (3017, 1055)]]]
def dist(pt1, pt2):
    return (pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2


def seg_dist(seg1, seg2):
    distances = [dist(seg1[i], seg2[j]) for i in range(2) for j in range(2)]
    return min(enumerate(distances), key=lambda x: x[1])


sorted_lines = []
for lines in final_line_points:
    connected_part = lines[0]
    non_connected = lines[1:]
    while non_connected:
        mat_dist = [seg_dist(connected_part, non_connected[i])[1] for i in range(len(non_connected))]
        i, min_dist = min(enumerate(mat_dist), key=lambda x: x[1])
        seg_to_connect = non_connected.pop(i)
        idx, real_dist = seg_dist(connected_part, seg_to_connect)
        if idx == 0:
            print("error: this case is not handled")
            exit()
        elif idx == 1:
            print("error: this case is not handled")
            exit()
        elif idx == 2:
            connected_part[1] = seg_to_connect[1]
        elif idx == 3:
            connected_part[1] = seg_to_connect[0]
    sorted_lines.append(connected_part)


class node():
    def __init__(self, name, box) -> None:
        super().__init__()
        self.name = name
        self.box = [(min(box[0][0], box[1][0]), min(box[0][1], box[1][1])),
                    (max(box[0][0], box[1][0]), max(box[0][1], box[1][1]))]
        self.args = []
        self.outputs = []

    def __contains__(self, item):
        return self.box[0][0] <= item[0] <= self.box[1][0] and self.box[0][1] <= item[1] <= self.box[1][1]

    def __str__(self) -> str:
        if self.args:
            return f"{self.name}{self.args}"
        else:
            return f"{self.name}"

    def __repr__(self) -> str:
        return self.__str__()

    def center(self):
        return (self.box[0][0] + self.box[1][0]) / 2, (self.box[0][1] + self.box[1][1]) / 2


nodes = [node(box[0], box[1:]) for box in boxes]

for line in sorted_lines:
    start_point = line[0]
    end_point = line[1]
    try:
        gate1 = next(node for node in nodes if start_point in node)
        gate2 = next(node for node in nodes if end_point in node)
        if gate1.center() < gate2.center():
            source_gate = gate1
            dest_gate = gate2
        else:
            source_gate = gate2
            dest_gate = gate1
        source_gate.outputs.append(dest_gate)
        dest_gate.args.append(source_gate)
    except StopIteration:
        print(f"{start_point} or {end_point} not in any of the boxes")

print(next(node for node in nodes if node.name == "OUTPUT"))

如果需要，我可以再解釋一天，或者您可以從這裡開始。無論如何，請與您的專案一起玩樂。

編輯:

我的目標是建立一個圖，其中節點是盒子，邊是線。問題在於這些行僅被定義為一組封閉的行。他們也很混亂，但首先。因此，第一步是將每組線變成一條直線。那就是我所謂的sorted_lines。

為了構建此列表，我使用了以下邏輯:

對於每組線，將其分成一個連線的部分和一個非連線的部分

連線的零件的初始化是集合的第一行。正如我所說，在這裡我假設第一行是正確的。嘗試改善此情況，因為在其他情況下此假設可能是錯誤的。

沒有連線的線路時，請執行以下操作:

查詢最接近連線零件的段

從未連線的部分中將其刪除

檢查線段的哪一端離連線的零件最近

如果它是線段的第一個點，則連線零件的最​​後一個點將成為線段的第二個點，否則第一個點將成為最後的點。

在檢查中，未處理的情況是要連線的線段關閉到連線零件的第一個點而不是最後一個點。由於我認為第一行是正確的，因此未處理。再一次，這可以改善。

現在，您已經對行進行了排序，對於其中的每一行，都找到包含每個端點的節點。選擇最少的作為源門，最右邊的作為目標門。由於邊緣未定向，因此我不得不假定方向。更新目標門的輸入和源門的輸出。

最後列印圖形的最後一個門。

出處