Optimisation des déplacements

This commit is contained in:
Alex committed 2026-10-23 17:02:48 +02:00
1 parent 99c30068fc
commit 437345c9b7
4 files changed
+229 -9

No files matched your search

+148
View File
@@ -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