python - 使用 OpenCV python 从手绘逻辑门图生成 bool 表达式

Question

输入手绘逻辑门图

我使用 YOLO 通过标签(字母)训练和识别 7 个不同的逻辑门。检测输入图像中的逻辑门和标签。

这里我得到了一个包含每个矩形的数组列表(框)。每个列表包含每个的以下详细信息长方形有序，• 矩形标签• 矩形左上角的 x,y 坐标• 矩形右下角的x,y 坐标

矩形框数组。

boxes = [['AND', (614, 98), (1146, 429)], ['NOT', (525, 1765), (1007, 1983)], ['NAND', (762, 1188), (1209,1528)], ['或非', (1323, 272), (1884, 682)], ['或', (575, 599), (1225, 985)], ['异或', (1393, 1368) , (2177,1842)], ['同或', (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)], ['输出', (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)]]]

那么如何使用以上 2 个数组(框、final_line_points)获得以下输出？

Answer 1

您的项目看起来很酷，所以我花了一些时间寻找解决方案。我想出了下面的代码。代码的结果是:

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

我假设如果一个元素比另一个元素最左边，那么它就是前一个 block 。我还假设在你的一组行中，第一行是正确的......这让我可以将你的 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。

为了构建这个列表，我使用了以下逻辑:

1. 对于每组线将其分成连通部分和非连通部分
2. 连接部分的初始化是集合的第一行。正如我所说，这里我假设第一行是正确的。尝试改进这一点，因为这种假设在其他情况下可能是错误的。

3. 当没有连接线时，执行以下操作:

   • 找到离连接部分最近的线段
   • 将其从非连接部分移除
   • 检查线段的哪一端离连接部分最近
   • 如果它是线段的第一个点，那么连接部分的最后一个点将成为线段的第二个点，否则第一个点将成为最后一个点。

在检查未处理的情况时，要连接的线段关闭到连接部分的第一个点而不是最后一个点。这没有被处理，因为我假设第一行是正确的。再次强调，这是可以改进的。

现在您已经对线条进行了排序，对于它们中的每一个，找到包含每一端的节点。选择最左边的作为源门，最右边的作为目的门。由于边缘没有方向，我不得不假设一个方向。更新目的门的输入和源门的输出。

最后打印图形的最后一个门。