# 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