使用OpenCV python从手绘逻辑门图中生成布尔表达式

2019-12-11 04:57:22 阅读：516 来源： 互联网

输入手绘逻辑门图

我使用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.

为了构建此列表,我使用了以下逻辑：

>对于每组线,将其分为一个连接部分和一个非连接部分
>连接零件的初始化是集合的第一行.正如我所说,在这里我假设第一行是正确的.尝试改善此情况,因为在其他情况下此假设可能是错误的.
>当没有连接的线路时,请执行以下操作：

>查找最接近连接零件的线段
>从未连接的零件上将其卸下
>检查分段的哪一端离连接的零件最近
>如果它是线段的第一个点,则连接零件的最后一个点将成为线段的第二个点,否则第一个点将成为最后的点.

在检查中,未处理的情况是要连接的线段关闭到连接零件的第一个点而不是最后一个点.因为我认为第一行是正确的,所以没有处理.再一次,这可以改善.

现在,您已经对行进行了排序,对于其中的每一行,都找到包含每个端点的节点.选择最少的作为源门,最右边的作为目标门.由于边缘未定向,因此我不得不假定方向.更新目标门的输入和源门的输出.

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

标签：opencv,image-processing,python
来源： https://codeday.me/bug/20191211/2106728.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

使用OpenCV python从手绘逻辑门图中生成布尔表达式