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

我假设,如果一个元素比另一个元素最左,则它是前一个块.我还假设在您的那组线中,第一个是正确的…这使我可以将您的14条几条线简化为14条线.

Boxes = [['AND',['NOT',['NAND',1528)],['NOR',(1323,272),(1884,682)],['OR',(575,599),(1225,985)],['XOR',(1393,1368),1842)],['XNOR',(2136,859),(2762,1231)],['A',(34,50),(321,224)],['B',(12,305),['C',581),(391,779)],['D',(0,828),(400,1060)],['E',1143),(354,1351)],['F',1418),(313,1615)],['G',['OUTPUT',1184)]]
final_line_points = [[[(87,[[(623,[(1348,[[(105,[[(107,1533),1510)],[(516,[[(111,396)],[(499,299)],[(503,310),(506,402)]],[[(123,157),(496,150)],[(493,144),(498,247)],[(495,[[(170,[[(936,264),257),(1240,485)],[(1234,481),(1535,458)]],[[(985,1361),(1343,1347)],[(1341,1344),[(1345,[[(991,778)],(1254,[[(2153,1581)]],[[(2444,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],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.

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

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

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

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

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

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