我有一个包含行（几何）的列表。这些线组成多个形状（正方形，矩形等）。然而，它们爆炸了，我试图想出一种方法，按照它们的形状将它们组合成单独的列表。例如，如果我的列表包含8行，我知道有两个矩形形状，我们想要创建两组，每组四行。 现在，我可以查询每一行的StartPoint（）和EndPoint（）。我正在考虑建立一个循环遍历列表的循环。选择列表中的第一行。获取其终点，然后检查它是否等于列表中其余行的任何起点。如果是，则将该行添加到具有第一行的列表中。然后取第二条线并做同样的事情，直到线的起点等于最后一条线的终点，并且第一条线的起点等于它的终点。 我该怎么办？
lines = [line1, line2, line3, line4, line5, line6, line7] #that means i have a square and a triangle
for i in lines:
shape1.append(lines[0])
sPoint = lines[0].StartPoint()
ePoint = lines[0].EndPoint()
if i.StartPoint() == ePoint:
shape1.append(i)
我不确定如何自动创建“形状”列表以及如何打破循环以便我不会在圈子中运行。
任何帮助将不胜感激。 谢谢，
答案 0 :(得分：1)
如果你花点时间抽象出问题，你会发现你真的只是在做图表。
图形由顶点和边缘组成。顶点是您的起点和终点。
我写了一段代码，一旦您了解了如何将数据转换为建议的格式，就可以帮助您解决问题。
<强>注释：
我建议您在阅读我的代码时阅读内置类型 set（）。
vertices = set(['A', 'C', 'B', 'E', 'D', 'G', 'F'])
#think of this as Line1.StartPoint()='A' Line1.EndPoint()='B' ...
edges = {'A': 'B',
'B': 'C',
'C': 'D',
'D': 'A',
'E': 'F',
'F': 'G',
'G': 'E'}
shapes = set()
#Check if we tested all edges
while len(vertices) is not 0:
next = vertices.pop()
shape = set()
while next not in shape:
shape.add(next)
next = edges[next]
shapes.add(frozenset(shape))
print shapes
结果：
＆gt;＆gt; set（[frozenset（['A'，'C'，'B'，'D']），frozenset（['E'，'G'，'F']）]）< / p>
编辑：主要的加速是可能的，但为了简单起见，遗漏了。
答案 1 :(得分：0)
不是最好的算法，但我很困，这应该可以让你开始：
lines = [line1, line2, line3, line4, line5, line6, line7]
shapes = []
while lines:
shape = [lines[0]]
i=1
while i < len(lines):
line1 = lines[i]
for line2 in lines[i+1:]:
if line2.start == line1.end or line2.end == line1.start or \
line2.start == line1.start or line2.end == line1.end:
shape.append(line2)
lines.pop(i)
i -= 1
if line2.end == shape[0].start or line2.start == shape[0].end or \
line2.end == shape[0].end or line2.start == shape[0].start:
shapes.append(shape)
shape = []
i += 1
要改进这一点，请尝试按起点和终点对行进行排序，并对连接线进行二进制搜索
答案 2 :(得分：0)
首先，让我们定义一个line类，其中包含2个点的坐标：
import itertools
import random
class line(object) :
"""
A line has 2 ends.
"""
def __init__(self, tup0, tup1 ) :
self.tup0 = tup0
self.tup1 = tup1
def __repr__( self ) :
return "line[{0}, {1}]".format( self.tup0, self.tup1 )
def StartPoint(self) :
return self.tup0
def EndPoint(self):
return self.tup1
def reverseLine(self) :
return line( self.tup1, self.tup0 )
我简单地枚举所有可能的形状（有效或无效），直到找到2个闭合形状：
以下是帮手：
def is_closed( lines ) :
"""
Return True if lines represents a closed shape (i.e., order matters)
"""
are0ToNConnected = all( l.tup1 == lines[i+1].tup0 for i,l in enumerate( lines[:-1] ) )
areFirstAndLastConnected = ( lines[-1].tup1 == lines[0].tup0 )
return are0ToNConnected and areFirstAndLastConnected
def is_any_closed( lines ) :
"""
Return True if at least one re-ordering of lines represents a closed shape (i.e., order doesnt matter)
"""
return any( is_closed(newLines)
for permutedLines in itertools.permutations( lines )
for newLines in itertools.product( * [ ( l, l.reverseLine() ) for l in permutedLines ] ) )
def k_way_partition( A, k ) :
"""
Generator for all k-way partitions of A
"""
if k == 1 :
yield [ A ]
elif len(A) == k :
yield [ [ a ] for a in A ]
else :
for partition in k_way_partition( A[1:], k ) : # add new element to one of the current clusters
for i, cluster in enumerate( partition ) :
yield partition[:i] + [ cluster + [ A[0] ] ] + partition[i+1:]
for partition in k_way_partition( A[1:], k-1 ) : # add new element to a new cluster
yield [ [ A[0] ] ] + partition
这是主要功能：
def find_shapes( lines, k ) :
"""
Looks for a partition of lines into k shapes, and print the solution if there is one.
"""
for partition in k_way_partition( lines, k ) :
if all( is_any_closed(cluster) for cluster in partition ) : # we found a solution
for j, cj in enumerate( partition ) :
print "shape {}: {}".format(j, cj )
break
让我们生成随机数据并尝试解决方案：
# square
lines = [ line( (0,0), (0,1) ) ]
lines.append( line( (0,1), (1,1) ) )
lines.append( line( (1,1), (1,0) ) )
lines.append( line( (1,0), (0,0) ) )
# triangle
lines.append( line( (2,2), (2,3) ) )
lines.append( line( (2,3), (3,2) ) )
lines.append( line( (3,2), (2,2) ) )
lines
random.shuffle( lines ) # randomize the order of lines
for i, l in enumerate( lines ) :
if random.random() < 0.5 :
lines[i] = l.reverseLine() # randomize order of coordinates
lines
缺货[8]：
[line[(0, 1), (1, 1)],
line[(1, 1), (1, 0)],
line[(2, 2), (2, 3)],
line[(0, 0), (1, 0)],
line[(3, 2), (2, 2)],
line[(3, 2), (2, 3)],
line[(0, 0), (0, 1)]]
现在让我们对随机数据运行我们的解决方案：
find_shapes( lines, 2 )
shape 0: [line[(3, 2), (2, 3)], line[(3, 2), (2, 2)], line[(2, 2), (2, 3)]]
shape 1: [line[(0, 0), (0, 1)], line[(0, 0), (1, 0)], line[(1, 1), (1, 0)], line[(0, 1), (1, 1)]]
有效！
答案 3 :(得分：0)
与@ ChristophHegemann的想法一样，想象一下数字实际上只是点的表示，所以在我的情况下，Line（1,4）或Edge（1,4）只是第1点和第4点之间的一条线。 / p>
from pprint import pprint
class Edge(object):
def __init__(self,a,b):
self.a = a
self.b = b
self.previous = None
self.next = None
def __repr__(self):
return "<Edge(%s,%s)>" % (self.a,self.b)
def find_shapes(lines):
# builds the graph
lines = link_lines(lines)
# explores the graph
shapes = extract_shapes(lines)
return shapes
def link_lines(lines):
# keep a safe copy of the list of lines. The original list will be tampered with.
lines_copy = list(lines)
for L in lines_copy:
lines.remove(L)
for line in lines:
# if current line's end is other line's start
if L.b == line.a:
L.next = line
line.previous = L
# if current line's start is other line's end
elif L.a == line.b:
L.previous = line
line.next = L
# if we found both the previous and the next edge then we're done for this edge.
# (edge has at most 1 previous and 1 next edge in a given shape).
# this of course supposes that any single edge is present in at most one shape.
if L.previous and L.next :
break
#put L back in
lines.append(L)
# return newly linked lines (graph)
return lines
def extract_shapes(lines):
lines_copy = list(lines)
shapes = []
while lines_copy :
L = lines_copy.pop()
shape = [L]
next_edge = L.next
# unlike @ChristophHegemann I work with edges, but the algorithm seems
# to be the same whether you work with edges or vertices
while next_edge != L:
shape.append(next_edge)
lines_copy.remove(next_edge)
next_edge = next_edge.next
shapes.append(shape)
return shapes
# list of lines
# let's pretend shapes are : L1,L10,L2,L4 and L5,L3,L7,L11 and L6,L9,L8,L12
L1 = Edge(1,2)
L10 = Edge(2,3)
L2 = Edge(3,4)
L4 = Edge(4,1)
L5 = Edge(5,6)
L3 = Edge(6,7)
L7 = Edge(7,8)
L11 = Edge(8,5)
L6 = Edge(9,10)
L9 = Edge(10,11)
L8 = Edge(11,12)
L12 = Edge(12,9)
# random order of lines
lines = [L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12]
pprint(find_shapes(lines))
# chaouche@karabeela ~/CODE/TEST/PYTHON/SO $ python lines.py
# [[<Edge(12,9)>, <Edge(9,10)>, <Edge(10,11)>, <Edge(11,12)>],
# [<Edge(8,5)>, <Edge(5,6)>, <Edge(6,7)>, <Edge(7,8)>],
# [<Edge(2,3)>, <Edge(3,4)>, <Edge(4,1)>, <Edge(1,2)>]]
# chaouche@karabeela ~/CODE/TEST/PYTHON/SO $