Initiale version

This commit is contained in:
Alex committed 2026-10-24 20:39:34 +02:00
commit 00e9ba3434
19 files changed
+2586

No files matched your search

+537
View File
@@ -0,0 +1,537 @@
# coding=utf-8
"""
Noyau de calcul de l'extension « Dog Bandana », sans dependance a inkex.
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
des parametres).
Conventions :
- un contour (`rings`) est une liste d'anneaux, chaque anneau etant une liste
de points (x, y) fermee implicitement ; les trous suivent la regle pair-impair ;
- une polyligne est une liste de points (x, y) ;
- l'axe y est oriente vers le bas (repere SVG).
Le motif est un labyrinthe de Turing (bandes de largeur constante qui
serpentent, bifurquent et se terminent en bouts ronds) : `turing_pattern`
renvoie la ligne centrale de chaque bande, a tracer avec un trait a bouts
ronds. Seule dependance : numpy, fourni avec Inkscape (inkex en depend).
Les traits produits passent par `laser_order` avant d'etre ecrits : ils sont
enchaines et ordonnes pour limiter les deplacements a vide de la tete du laser.
"""
import math
import numpy as np
def parse_color(value, default=("#b3b3b3", 1.0)):
"""Couleur Inkscape (entier RGBA decimal ou 0x..., ou #rrggbb[aa]).
Renvoie (couleur CSS #rrggbb, opacite entre 0 et 1). Le parametre
« color » d'Inkscape arrive sous forme d'entier RGBA ; on le decode
nous-memes pour ne pas dependre de l'API couleur d'inkex, qui a change
entre les versions 1.x.
"""
text = str(value).strip()
try:
if text.startswith("#"):
digits = text[1:]
if len(digits) == 3:
digits = "".join(c * 2 for c in digits)
if len(digits) == 6:
digits += "ff"
if len(digits) != 8:
return default
number = int(digits, 16)
else:
number = int(text, 0)
except ValueError:
return default
number &= 0xFFFFFFFF
red, green, blue = (number >> 24) & 255, (number >> 16) & 255, (number >> 8) & 255
alpha = (number & 255) / 255.0
return "#{:02x}{:02x}{:02x}".format(red, green, blue), round(alpha, 4)
def polylines_to_d(polylines, precision=4):
"""Donnees `d` d'un chemin SVG : une polyligne par sous-chemin."""
fmt = "{:.%df},{:.%df}" % (precision, precision)
parts = []
for polyline in polylines:
if len(polyline) < 2:
continue
parts.append("M " + fmt.format(*polyline[0]))
parts.extend("L " + fmt.format(*point) for point in polyline[1:])
return " ".join(parts)
# --------------------------------------------------------------------------
# Ordre de gravure (decoupeuse laser)
# --------------------------------------------------------------------------
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 _is_closed(line):
return len(line) > 2 and _key(line[0]) == _key(line[-1])
def chain_polylines(polylines):
"""Met bout a bout les polylignes qui se touchent par leurs extremites.
Le laser parcourt alors chaque resultat d'un trait, sans lever la tete.
Les polylignes sont les aretes d'un graphe dont les noeuds sont leurs
extremites ; on part d'abord des noeuds de degre impair (bouts de
branche) : un parcours qui y commence ne peut s'arreter que sur un autre
noeud impair, ce qui limite le nombre de traits, donc de sauts a vide.
Une polyligne deja fermee (boucle) est gardee telle quelle.
"""
out = []
points = {}
adjacency = {} # noeud -> [(numero de polyligne, voisin)]
lines = [list(line) for line in polylines if len(line) >= 2]
for index, line in enumerate(lines):
a, b = _key(line[0]), _key(line[-1])
if a == b:
out.append(line)
continue
points.setdefault(a, line[0])
points.setdefault(b, line[-1])
adjacency.setdefault(a, []).append((index, b))
adjacency.setdefault(b, []).append((index, a))
used = [False] * len(lines)
def free_edges(node):
edges = adjacency[node]
edges[:] = [edge for edge in edges if not used[edge[0]]]
return edges
def walk(node):
chain = [points[node]]
while True:
edges = free_edges(node)
if not edges:
return chain
index, following = edges.pop()
used[index] = True
line = lines[index]
if _key(line[0]) != node:
line = line[::-1]
chain.extend(line[1:])
node = following
for node in adjacency:
if len(free_edges(node)) % 2:
out.append(walk(node))
for node in adjacency: # reste : circuits fermes
while free_edges(node):
out.append(walk(node))
return out
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 = [list(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 _is_closed(line):
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 not _is_closed(line):
line = line[::-1]
else: # boucle : rotation
line = line[k:-1] + line[:k] + [line[k]]
ordered.append(line)
position = line[-1]
return ordered
def laser_order(polylines, start=(0.0, 0.0)):
"""Enchaine puis ordonne les traits : a appliquer avant polylines_to_d.
`start` : position de la tete (fin du trace precedent, ou origine).
La position finale est le dernier point de la derniere polyligne.
"""
return order_polylines(chain_polylines(polylines), start)
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
# --------------------------------------------------------------------------
# Motif de Turing (labyrinthe)
# --------------------------------------------------------------------------
#
# Regime « labyrinthe » de l'equation de Swift-Hohenberg :
# du/dt = r.u - (1 + laplacien)^2 u - u^3
# integree sur une grille de pixels couvrant la forme. Partant d'un bruit
# aleatoire, le champ u s'organise en bandes de periode 2.pi (unites reduites).
# Les bandes positives sont amincies en squelette d'un pixel, suivi en
# polylignes, lisse puis simplifie.
PIXELS_PER_PERIOD = 8 # resolution du calcul
STEPS = 60 # pas d'integration : plus, bandes plus longues
SMOOTHING = 4 # passes de lissage des lignes centrales
EDGE_MODES = ("cut", "follow")
MAX_PIXELS = 3000000 # au-dela, calcul trop long dans Inkscape
def rasterize(rings, x0, y0, step, nx, ny):
"""Masque booleen (ny, nx) des centres de pixels interieurs (pair-impair).
Pixel (i, j) : centre en (x0 + (j + 0.5) * step, y0 + (i + 0.5) * step).
Balayage par lignes : pour chaque ligne, abscisses des intersections avec
les aretes, triees ; un pixel est dedans s'il a un nombre impair
d'intersections a sa gauche.
"""
mask = np.zeros((ny, nx), dtype=bool)
edges = [(ring[k], ring[(k + 1) % len(ring)]) for ring in rings
for k in range(len(ring))]
if not edges:
return mask
ax, ay, bx, by = (np.array(v, dtype=float) for v in zip(
*[(a[0], a[1], b[0], b[1]) for a, b in edges]))
columns = x0 + (np.arange(nx) + 0.5) * step
for i in range(ny):
y = y0 + (i + 0.5) * step
# Arete demi-ouverte : un sommet partage n'est compte qu'une fois.
hit = (ay <= y) != (by <= y)
if not hit.any():
continue
t = (y - ay[hit]) / (by[hit] - ay[hit])
xs = np.sort(ax[hit] + t * (bx[hit] - ax[hit]))
mask[i] = np.searchsorted(xs, columns) % 2 == 1
return mask
def erode(mask, radius):
"""Erosion du masque par un disque de `radius` pixels.
Convolution par FFT : un pixel reste s'il n'y a aucun pixel exterieur
dans le disque qui l'entoure. La convolution est periodique : la grille
doit garder une bordure exterieure d'au moins `radius` pixels.
"""
if radius <= 0:
return mask.copy()
ny, nx = mask.shape
iy = np.minimum(np.arange(ny), ny - np.arange(ny))[:, None]
ix = np.minimum(np.arange(nx), nx - np.arange(nx))[None, :]
disk = (ix ** 2 + iy ** 2 <= radius ** 2).astype(float)
hits = np.fft.irfft2(np.fft.rfft2((~mask).astype(float)) * np.fft.rfft2(disk),
s=mask.shape)
return mask & (hits < 0.5)
def swift_hohenberg(shape, pixels_per_period=PIXELS_PER_PERIOD, seed=1,
steps=STEPS, outside=None, r=0.35, dt=0.5):
"""Champ u (ny, nx) du regime labyrinthe.
Schema spectral semi-implicite : partie lineaire implicite (stable quel
que soit le pas de temps), terme cubique explicite ; bords periodiques.
`outside` (masque booleen, optionnel) : pixels ou u est force a -1 a
chaque pas ; les bandes s'arretent alors avant ce masque et longent son
bord, au lieu d'etre coupees net.
"""
ny, nx = shape
rng = np.random.default_rng(seed)
u = 0.1 * rng.standard_normal((ny, nx))
spacing = 2 * math.pi / pixels_per_period # pixel en unites reduites
kx = 2 * math.pi * np.fft.rfftfreq(nx, d=spacing)
ky = 2 * math.pi * np.fft.fftfreq(ny, d=spacing)
k2 = ky[:, None] ** 2 + kx[None, :] ** 2
denominator = 1 - dt * (r - (1 - k2) ** 2)
for _ in range(steps):
if outside is not None:
u[outside] = -1.0
u_hat = np.fft.rfft2(u - dt * u ** 3)
u = np.fft.irfft2(u_hat / denominator, s=(ny, nx))
if outside is not None:
u[outside] = -1.0
return u
def skeletonize(binary):
"""Squelette d'un pixel d'epaisseur (Zhang-Suen), vectorise avec numpy."""
img = np.pad(binary.astype(np.uint8), 1)
while True:
changed = False
for first in (True, False):
p2, p3, p4 = img[:-2, 1:-1], img[:-2, 2:], img[1:-1, 2:]
p5, p6, p7 = img[2:, 2:], img[2:, 1:-1], img[2:, :-2]
p8, p9 = img[1:-1, :-2], img[:-2, :-2]
around = [p2, p3, p4, p5, p6, p7, p8, p9, p2]
neighbours = sum(around[:8])
transitions = sum(((a == 0) & (b == 1)).astype(np.uint8)
for a, b in zip(around, around[1:]))
if first:
c1, c2 = p2 * p4 * p6, p4 * p6 * p8
else:
c1, c2 = p2 * p4 * p8, p2 * p6 * p8
remove = ((img[1:-1, 1:-1] == 1) & (neighbours >= 2) & (neighbours <= 6)
& (transitions == 1) & (c1 == 0) & (c2 == 0))
if remove.any():
img[1:-1, 1:-1][remove] = 0
changed = True
if not changed:
return img[1:-1, 1:-1].astype(bool)
_NEIGHBOURS = ((-1, 0), (0, 1), (1, 0), (0, -1), (-1, -1), (-1, 1), (1, 1), (1, -1))
def _skeleton_graph(skeleton):
"""Voisins de chaque pixel du squelette.
Liaisons 8-connexes, sauf une diagonale doublee par deux liaisons droites
(coin en « L ») : elle creerait de faux carrefours.
"""
pixels = set(zip(*(index.tolist() for index in np.nonzero(skeleton))))
graph = {}
for (i, j) in pixels:
links = []
for di, dj in _NEIGHBOURS:
q = (i + di, j + dj)
if q not in pixels:
continue
if di and dj and ((i + di, j) in pixels or (i, j + dj) in pixels):
continue
links.append(q)
graph[(i, j)] = links
return graph
def trace_skeleton(skeleton, min_spur=0):
"""Polylignes de pixels (ligne, colonne) qui suivent le squelette.
Chaque branche relie deux noeuds (bouts ou carrefours) ; les boucles sans
noeud sont suivies a part ; un pixel isole donne une polyligne d'un point.
Les ergots (branche libre de moins de `min_spur` pixels accrochee a un
carrefour, artefacts de l'amincissement) sont supprimes.
"""
graph = _skeleton_graph(skeleton)
seen = set() # liaisons deja parcourues
def follow(previous, current, line):
seen.add((previous, current))
seen.add((current, previous))
while len(graph[current]) == 2 and current != line[0]:
line.append(current)
a, b = graph[current]
following = b if a == previous else a
if (current, following) in seen:
break
seen.add((current, following))
seen.add((following, current))
previous, current = current, following
line.append(current)
return line
lines = []
for node in sorted(p for p, links in graph.items() if len(links) != 2):
if not graph[node]:
lines.append([node])
for nxt in graph[node]:
if (node, nxt) not in seen:
lines.append(follow(node, nxt, [node]))
for p in sorted(graph): # boucles isolees
links = graph[p]
if len(links) == 2 and (p, links[0]) not in seen:
lines.append(follow(p, links[0], [p]))
if min_spur <= 0:
return lines
degree = {p: len(links) for p, links in graph.items()}
kept = []
for line in lines:
ends = sorted((degree[line[0]], degree[line[-1]]))
if 1 < len(line) <= min_spur and ends[0] == 1 and ends[1] >= 3:
continue
kept.append(line)
return kept
def smooth_polyline(points, passes=2):
"""Lissage par moyenne glissante (1/4, 1/2, 1/4), extremites fixes.
Une boucle fermee (premier point = dernier) est lissee tout du long.
"""
if len(points) < 3:
return [tuple(p) for p in points]
closed = tuple(points[0]) == tuple(points[-1])
pts = np.array(points[:-1] if closed else points, dtype=float)
for _ in range(passes):
if closed:
pts = 0.25 * np.roll(pts, 1, 0) + 0.5 * pts + 0.25 * np.roll(pts, -1, 0)
else:
inner = 0.25 * pts[:-2] + 0.5 * pts[1:-1] + 0.25 * pts[2:]
pts = np.vstack((pts[:1], inner, pts[-1:]))
out = [tuple(p) for p in pts.tolist()]
if closed:
out.append(out[0])
return out
def simplify_polyline(points, tolerance):
"""Ramer-Douglas-Peucker : ne garde que les sommets utiles a `tolerance` pres."""
if len(points) < 3:
return [tuple(p) for p in points]
pts = np.asarray(points, dtype=float)
keep = np.zeros(len(pts), dtype=bool)
keep[0] = keep[-1] = True
stack = [(0, len(pts) - 1)]
while stack:
a, b = stack.pop()
if b - a < 2:
continue
sx, sy = pts[b] - pts[a]
rel = pts[a + 1:b] - pts[a]
length = math.hypot(sx, sy)
if length == 0:
dist = np.hypot(rel[:, 0], rel[:, 1])
else:
dist = np.abs(rel[:, 0] * sy - rel[:, 1] * sx) / length
k = int(np.argmax(dist))
if dist[k] > tolerance:
keep[a + 1 + k] = True
stack.extend(((a, a + 1 + k), (a + 1 + k, b)))
return [tuple(p) for p in pts[keep].tolist()]
def _grid(rings, period, pixels_per_period):
"""Origine, pas et taille (x0, y0, step, nx, ny) de la grille de calcul.
Bordure exterieure de deux periodes : le champ y vaut -1 et l'erosion
par FFT (periodique) ne deborde pas d'un cote sur l'autre.
"""
xs = [x for ring in rings for x, _y in ring]
ys = [y for ring in rings for _x, y in ring]
step = period / pixels_per_period
pad = 2 * pixels_per_period
nx = int(math.ceil((max(xs) - min(xs)) / step)) + 2 * pad
ny = int(math.ceil((max(ys) - min(ys)) / step)) + 2 * pad
return min(xs) - pad * step, min(ys) - pad * step, step, nx, ny
def grid_pixels(rings, period, pixels_per_period=PIXELS_PER_PERIOD):
"""Nombre de pixels de la grille de calcul (0 si rien a calculer)."""
if period <= 0 or not any(rings):
return 0
_x0, _y0, _step, nx, ny = _grid(rings, period, pixels_per_period)
return nx * ny
def turing_pattern(rings, period, line_width, margin=0.0, seed=1, edge="cut",
pixels_per_period=PIXELS_PER_PERIOD, steps=STEPS):
"""Lignes centrales du labyrinthe de Turing qui remplit `rings`.
- period : distance entre les lignes centrales de deux bandes voisines ;
- line_width : epaisseur du trait (bouts ronds compris) : le trait entier
reste dans la forme ;
- margin : espace libre entre le bord de la forme et le trait ;
- seed : graine du tirage aleatoire (autre nombre, autre motif) ;
- edge : "cut", le motif est calcule sans tenir compte de la forme puis
coupe a son bord (comme un tissu decoupe) ; "follow", les bandes
s'arretent avant le bord et le longent.
Renvoie des polylignes en coordonnees du document ; un point isole est
une polyligne de deux points confondus (un trait a bouts ronds le dessine).
"""
if period <= 0 or not any(rings):
return []
x0, y0, step, nx, ny = _grid(rings, period, pixels_per_period)
mask = rasterize(rings, x0, y0, step, nx, ny)
inset = max(0.0, margin) + max(0.0, line_width) / 2
region = erode(mask, inset / step)
if not region.any():
return []
follow = edge == "follow"
u = swift_hohenberg(region.shape, pixels_per_period, seed, steps,
outside=~region if follow else None)
skeleton = skeletonize(u > 0) & region
lines = trace_skeleton(skeleton, min_spur=pixels_per_period / 2)
out = []
for line in lines:
points = [(x0 + (j + 0.5) * step, y0 + (i + 0.5) * step) for i, j in line]
if len(points) == 1:
out.append([points[0], points[0]])
else:
out.append(simplify_polyline(smooth_polyline(points, SMOOTHING), 0.1 * step))
return out