Optimisation des déplacements
This commit is contained in:
1 parent
99c30068fc
commit
437345c9b7
4 files changed
+229
-9
No files matched your search
+148
@@ -293,3 +293,151 @@ def _to_world(point, angle, anchor):
|
||||
def segments_to_polylines(segments):
|
||||
"""Segments -> polylines a deux points (pour polylines_to_d)."""
|
||||
return [[p, q] for p, q in segments]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Ordre de gravure
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def _key(point):
|
||||
"""Cle d'un point : deux extremites a 1e-6 pres sont le meme noeud."""
|
||||
return round(point[0], 6), round(point[1], 6)
|
||||
|
||||
|
||||
def chain_segments(segments):
|
||||
"""Segments -> polylignes : les segments qui se touchent sont mis bout a bout.
|
||||
|
||||
Le laser parcourt alors chaque polyligne d'un trait, sans lever la tete.
|
||||
On part d'abord des noeuds de degre impair (bouts de branche, centres des
|
||||
« Y ») : un parcours qui y commence ne peut s'arreter que sur un autre
|
||||
noeud impair, ce qui limite le nombre de polylignes, donc de sauts a vide.
|
||||
"""
|
||||
points = {}
|
||||
adjacency = {} # noeud -> [(numero du segment, voisin)]
|
||||
for index, (p, q) in enumerate(segments):
|
||||
a, b = _key(p), _key(q)
|
||||
if a == b:
|
||||
continue
|
||||
points.setdefault(a, p)
|
||||
points.setdefault(b, q)
|
||||
adjacency.setdefault(a, []).append((index, b))
|
||||
adjacency.setdefault(b, []).append((index, a))
|
||||
used = [False] * len(segments)
|
||||
|
||||
def free_edges(node):
|
||||
edges = adjacency[node]
|
||||
edges[:] = [edge for edge in edges if not used[edge[0]]]
|
||||
return edges
|
||||
|
||||
def walk(node):
|
||||
line = [points[node]]
|
||||
while True:
|
||||
edges = free_edges(node)
|
||||
if not edges:
|
||||
return line
|
||||
index, node = edges.pop()
|
||||
used[index] = True
|
||||
line.append(points[node])
|
||||
|
||||
polylines = []
|
||||
for node in adjacency:
|
||||
if len(free_edges(node)) % 2:
|
||||
polylines.append(walk(node))
|
||||
for node in adjacency: # reste : boucles fermees
|
||||
while free_edges(node):
|
||||
polylines.append(walk(node))
|
||||
return polylines
|
||||
|
||||
|
||||
def order_polylines(polylines, start=(0.0, 0.0)):
|
||||
"""Ordonne les polylignes pour limiter les deplacements a vide du laser.
|
||||
|
||||
Plus proche voisin : depuis la fin de la polyligne precedente (ou
|
||||
`start`), on enchaine sur l'entree libre la plus proche. Une polyligne
|
||||
ouverte peut etre parcourue dans les deux sens ; une boucle fermee peut
|
||||
commencer a n'importe lequel de ses sommets. Les entrees sont rangees
|
||||
dans une grille pour ne pas tout comparer a chaque pas.
|
||||
"""
|
||||
polylines = [line for line in polylines if len(line) >= 2]
|
||||
if not polylines:
|
||||
return []
|
||||
entries = [] # (numero de polyligne, sommet d'entree)
|
||||
for index, line in enumerate(polylines):
|
||||
if len(line) > 2 and _key(line[0]) == _key(line[-1]):
|
||||
entries.extend((index, k) for k in range(len(line) - 1))
|
||||
else:
|
||||
entries.extend(((index, 0), (index, len(line) - 1)))
|
||||
|
||||
xs = [polylines[i][k][0] for i, k in entries]
|
||||
ys = [polylines[i][k][1] for i, k in entries]
|
||||
x0, y0 = min(xs), min(ys)
|
||||
width, height = max(xs) - x0, max(ys) - y0
|
||||
cell = math.sqrt(width * height / len(entries)) or max(width, height) / len(entries) or 1.0
|
||||
nx, ny = int(width / cell), int(height / cell)
|
||||
grid = {}
|
||||
for entry, x, y in zip(entries, xs, ys):
|
||||
grid.setdefault((int((x - x0) / cell), int((y - y0) / cell)), []).append(entry)
|
||||
|
||||
done = [False] * len(polylines)
|
||||
|
||||
def ring(cx, cy, r):
|
||||
"""Cellules de la grille a distance r (en cellules) de (cx, cy)."""
|
||||
if r == 0:
|
||||
yield cx, cy
|
||||
return
|
||||
for gx in range(max(cx - r, 0), min(cx + r, nx) + 1):
|
||||
if 0 <= cy - r <= ny:
|
||||
yield gx, cy - r
|
||||
if 0 <= cy + r <= ny:
|
||||
yield gx, cy + r
|
||||
for gy in range(max(cy - r + 1, 0), min(cy + r - 1, ny) + 1):
|
||||
if 0 <= cx - r <= nx:
|
||||
yield cx - r, gy
|
||||
if 0 <= cx + r <= nx:
|
||||
yield cx + r, gy
|
||||
|
||||
def nearest(x, y):
|
||||
cx = int(math.floor((x - x0) / cell))
|
||||
cy = int(math.floor((y - y0) / cell))
|
||||
r = max(0, -cx, cx - nx, -cy, cy - ny) # premier anneau dans la grille
|
||||
r_max = max(cx, nx - cx, cy, ny - cy, r)
|
||||
best, best_d = None, float("inf")
|
||||
while r <= r_max and (r - 1) * cell < best_d:
|
||||
for key in ring(cx, cy, r):
|
||||
bucket = grid.get(key)
|
||||
if not bucket:
|
||||
continue
|
||||
bucket[:] = [e for e in bucket if not done[e[0]]]
|
||||
for index, k in bucket:
|
||||
px, py = polylines[index][k]
|
||||
d = math.hypot(px - x, py - y)
|
||||
if d < best_d:
|
||||
best, best_d = (index, k), d
|
||||
r += 1
|
||||
return best
|
||||
|
||||
ordered = []
|
||||
position = start
|
||||
for _ in range(len(polylines)):
|
||||
index, k = nearest(*position)
|
||||
done[index] = True
|
||||
line = polylines[index]
|
||||
if k == 0:
|
||||
pass
|
||||
elif k == len(line) - 1 and _key(line[0]) != _key(line[-1]):
|
||||
line = line[::-1]
|
||||
else: # boucle : rotation
|
||||
line = line[k:-1] + line[:k] + [line[k]]
|
||||
ordered.append(line)
|
||||
position = line[-1]
|
||||
return ordered
|
||||
|
||||
|
||||
def travel_length(polylines, start=(0.0, 0.0)):
|
||||
"""Longueur totale des deplacements a vide (tete levee) entre polylignes."""
|
||||
total = 0.0
|
||||
position = start
|
||||
for line in polylines:
|
||||
total += math.hypot(line[0][0] - position[0], line[0][1] - position[1])
|
||||
position = line[-1]
|
||||
return total
|
||||
Reference in new issue
Block a user