# coding=utf-8 """ Noyau de calcul de l'extension « Skull Pattern Fill », sans dependance a inkex. Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema des parametres). Le remplissage reprend le principe du motif de reference (doc/patern.png) : un meme crane, repete a des tailles, des angles et en miroir differents, les cranes s'empilant sans laisser de vide ; les petits sont dessines d'abord, les grands viennent par-dessus. 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) ; - une boucle de Bezier est une liste de segments cubiques (p0, c1, c2, p3), fermee ; - le crane est dessine dans un repere unite : centre en (0, 0), hauteur 1 (y de -0,5 a 0,5), largeur 0,80 ; c'est le dessin de doc/dessin.svg sans ses cornes, vu de trois quarts et tourne vers la gauche ; - l'axe y est oriente vers le bas (repere SVG). """ import math import random from skull_drawing import BODY_D, INK_D 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) # -------------------------------------------------------------------------- # Le crane # -------------------------------------------------------------------------- def parse_loops(d): """Donnees `d` en commandes absolues M, C, Z -> boucles de Bezier. Ne lit que la forme produite par docs/extraire_crane.py (et par loops_to_d) : un sous-chemin par boucle, uniquement des cubiques. """ loops, loop, start, current = [], None, None, None tokens = d.replace(",", " ").split() i = 0 while i < len(tokens): command = tokens[i] if command == "M": start = current = (float(tokens[i + 1]), float(tokens[i + 2])) loop = [] i += 3 elif command == "C": values = [float(v) for v in tokens[i + 1:i + 7]] c1, c2, p3 = tuple(values[0:2]), tuple(values[2:4]), tuple(values[4:6]) loop.append((current, c1, c2, p3)) current = p3 i += 7 elif command == "Z": if current != start: loop.append((current, current, start, start)) loops.append(loop) current = start i += 1 else: raise ValueError("commande non geree : {}".format(command)) return loops _GEOMETRY = None def skull_geometry(): """Le crane dans son repere unite : (silhouette, encre). Dessin de doc/dessin.svg, cornes retirees (donnees de skull_drawing.py, regenerees par docs/extraire_crane.py). `silhouette` est le contour exterieur, a remplir de la couleur de l'os pour cacher les cranes du dessous ; `encre` est le trait et les ombres, un seul chemin a remplir en regle non nulle (les trous blancs tournent en sens inverse). """ global _GEOMETRY if _GEOMETRY is None: _GEOMETRY = (parse_loops(BODY_D), parse_loops(INK_D)) return _GEOMETRY def placement_matrix(x, y, size, angle=0.0, mirror=False): """Matrice affine (a, b, c, d, e, f) du repere unite vers le document. Ordre : miroir horizontal, mise a l'echelle `size`, rotation `angle` (degres, sens horaire a l'ecran comme dans Inkscape), translation. """ rad = math.radians(angle) cos_a, sin_a = math.cos(rad) * size, math.sin(rad) * size sx = -1.0 if mirror else 1.0 return (cos_a * sx, sin_a * sx, -sin_a, cos_a, x, y) def apply_matrix(matrix, point): a, b, c, d, e, f = matrix return (a * point[0] + c * point[1] + e, b * point[0] + d * point[1] + f) def loops_to_d(loops, matrix=(1, 0, 0, 1, 0, 0), precision=3): """Donnees `d` (M, C, Z absolus) de boucles de Bezier transformees. Une transformation affine laisse une courbe de Bezier de meme forme : transformer les points de controle suffit, le chemin produit n'a pas besoin d'attribut `transform`. """ fmt = "{:.%df},{:.%df}" % (precision, precision) parts = [] for loop in loops: start = apply_matrix(matrix, loop[0][0]) parts.append("M " + fmt.format(*start)) for _p0, c1, c2, p3 in loop: parts.append("C " + " ".join(fmt.format(*apply_matrix(matrix, p)) for p in (c1, c2, p3))) parts.append("Z") return " ".join(parts) def skull_paths(placement, precision=3): """(d de la silhouette, d de l'encre) d'un crane place.""" matrix = placement_matrix(*placement) return tuple(loops_to_d(loops, matrix, precision) for loops in skull_geometry()) # -------------------------------------------------------------------------- # Region a remplir # -------------------------------------------------------------------------- def rings_bbox(rings): xs = [x for ring in rings for x, _y in ring] ys = [y for ring in rings for _x, y in ring] if not xs: return None return min(xs), min(ys), max(xs), max(ys) def point_in_rings(point, rings): """Point dans la region (regle pair-impair, les trous sont exclus).""" x, y = point inside = False for ring in rings: n = len(ring) for i in range(n): x1, y1 = ring[i] x2, y2 = ring[(i + 1) % n] if (y1 > y) != (y2 > y): if x < x1 + (y - y1) * (x2 - x1) / (y2 - y1): inside = not inside return inside def distance_to_rings(point, rings): """Distance d'un point au bord de la region.""" px, py = point best = float("inf") for ring in rings: n = len(ring) for i in range(n): x1, y1 = ring[i] x2, y2 = ring[(i + 1) % n] dx, dy = x2 - x1, y2 - y1 length2 = dx * dx + dy * dy t = 0.0 if not length2 else max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / length2)) best = min(best, math.hypot(px - x1 - t * dx, py - y1 - t * dy)) return best # -------------------------------------------------------------------------- # Geometrie visible # # Destination : la gravure laser. La machine grave tout trait present dans # le fichier, meme cache sous un autre objet ou rendu invisible par un # masque. On ne produit donc que l'encre reellement visible : # - pour chaque crane, son encre, limitee a la forme, moins les silhouettes # de tous les cranes poses au-dessus de lui ; # - les interstices : la forme moins l'union de toutes les silhouettes. # Les silhouettes elles-memes (le blanc de l'os) ne sont pas ecrites. # # Les calculs se font sur des polygones (courbes aplaties) avec le moteur # booleen de boolean_ops. L'encre se lit en regle pair-impair (equivalente, # pour ce dessin, a sa regle non nulle : ses trous tournent en sens inverse # et ne se chevauchent pas) ; les silhouettes, toutes remises dans le meme # sens, en regle non nulle, ce qui revient a leur union. # -------------------------------------------------------------------------- IDENTITY = (1.0, 0.0, 0.0, 1.0, 0.0, 0.0) def _bezier_point(q, t): s = 1.0 - t a, b, c, d = s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t return (a * q[0][0] + b * q[1][0] + c * q[2][0] + d * q[3][0], a * q[0][1] + b * q[1][1] + c * q[2][1] + d * q[3][1]) def flatten_loops(loops, matrix=IDENTITY, step=0.01): """Boucles de Bezier transformees -> anneaux (polygones fermes). Chaque courbe est decoupee en morceaux d'au plus `step` environ (longueur du polygone de controle), 24 au plus. """ rings = [] for loop in loops: ring = [] for segment in loop: q = [apply_matrix(matrix, p) for p in segment] length = sum(math.hypot(b[0] - a[0], b[1] - a[1]) for a, b in zip(q, q[1:])) count = max(1, min(24, int(math.ceil(length / step)))) ring.extend(_bezier_point(q, k / count) for k in range(count)) if len(ring) >= 3: rings.append(ring) return rings def simplify_ring(ring, tolerance): """Anneau simplifie (Douglas-Peucker) : ecart au trace d'origine <= tolerance.""" n = len(ring) if n < 4: return ring # On coupe l'anneau en deux au point le plus eloigne du premier. far = max(range(n), key=lambda i: (ring[i][0] - ring[0][0]) ** 2 + (ring[i][1] - ring[0][1]) ** 2) keep = [False] * (n + 1) keep[0] = keep[far] = keep[n] = True points = ring + [ring[0]] stack = [(0, far), (far, n)] while stack: i, j = stack.pop() a, b = points[i], points[j] dx, dy = b[0] - a[0], b[1] - a[1] norm = math.hypot(dx, dy) best, index = tolerance, None for k in range(i + 1, j): p = points[k] if norm: dist = abs(dx * (p[1] - a[1]) - dy * (p[0] - a[0])) / norm else: dist = math.hypot(p[0] - a[0], p[1] - a[1]) if dist > best: best, index = dist, k if index is not None: keep[index] = True stack.append((i, index)) stack.append((index, j)) result = [points[k] for k in range(n) if keep[k]] return result if len(result) >= 3 else ring def rings_to_d(rings, precision=2): """Donnees `d` compactes d'anneaux fermes : M absolu, puis l relatifs. Les ecarts sont pris entre points deja arrondis : ils ne cumulent pas d'erreur. Les points confondus apres arrondi sont omis. """ scale = 10 ** precision def num(v): text = "{:.{}f}".format(v / scale, precision).rstrip("0").rstrip(".") return "0" if text in ("", "-0") else text parts = [] for ring in rings: pts = [(int(round(x * scale)), int(round(y * scale))) for x, y in ring] kept = [pts[0]] for p in pts[1:]: if p != kept[-1]: kept.append(p) if len(kept) < 3: continue parts.append("M{},{}l".format(num(kept[0][0]), num(kept[0][1]))) parts.append(" ".join("{},{}".format(num(b[0] - a[0]), num(b[1] - a[1])) for a, b in zip(kept, kept[1:]))) parts.append("z") return "".join(parts) def ring_area(ring): """Aire signee (positive dans le sens horaire a l'ecran, y vers le bas).""" return 0.5 * sum(a[0] * b[1] - b[0] * a[1] for a, b in zip(ring, ring[1:] + ring[:1])) def _ring_bbox(ring): xs = [p[0] for p in ring] ys = [p[1] for p in ring] return min(xs), min(ys), max(xs), max(ys) def _boxes_overlap(a, b): return a[0] <= b[2] and b[0] <= a[2] and a[1] <= b[3] and b[1] <= a[3] class _EdgeGrid(object): """Cases traversees par les cotes d'anneaux : dit vite si une boite est loin de tout bord.""" def __init__(self, rings): edges = [(r[i], r[(i + 1) % len(r)]) for r in rings for i in range(len(r))] total = sum(math.hypot(b[0] - a[0], b[1] - a[1]) for a, b in edges) self.cell = max(4.0 * total / max(len(edges), 1), 1e-9) self.cells = set() c = self.cell for a, b in edges: for i in range(int(math.floor(min(a[0], b[0]) / c)), int(math.floor(max(a[0], b[0]) / c)) + 1): for j in range(int(math.floor(min(a[1], b[1]) / c)), int(math.floor(max(a[1], b[1]) / c)) + 1): self.cells.add((i, j)) def touches(self, box): c = self.cell for i in range(int(math.floor(box[0] / c)), int(math.floor(box[2] / c)) + 1): for j in range(int(math.floor(box[1] / c)), int(math.floor(box[3] / c)) + 1): if (i, j) in self.cells: return True return False class Region(object): """Region a remplir : anneaux en regle pair-impair.""" def __init__(self, rings): self.rings = [ring for ring in rings if len(ring) >= 3] self.box = rings_bbox(self.rings) self.grid = _EdgeGrid(self.rings) def contains(self, point): return point_in_rings(point, self.rings) _RADIUS = None def skull_radius(): """Rayon du disque contenant le crane, pour une hauteur 1.""" global _RADIUS if _RADIUS is None: body, _ink = skull_geometry() _RADIUS = max(math.hypot(*p) for seg in body[0] for p in seg) return _RADIUS _FLAT = {} def _flat_skull(step): """Crane aplati et simplifie une fois pour toutes, dans son repere unite. Renvoie (silhouette, anneaux d'encre). La silhouette est remise dans le sens horaire, pour que l'union des silhouettes en regle non nulle ne fasse pas de trou la ou deux cranes de sens opposes se chevauchent. """ if step not in _FLAT: body, ink = skull_geometry() # Ecart tolere : 0,25 % de la hauteur (moins d'un dixieme de # millimetre sur un crane de 30 mm, sous la finesse d'un laser). tolerance = 0.25 * step outline = simplify_ring(flatten_loops(body, step=step)[0], tolerance) if ring_area(outline) < 0: outline = outline[::-1] rings = [simplify_ring(ring, tolerance) for ring in flatten_loops(ink, step=step)] _FLAT[step] = (outline, rings) return _FLAT[step] def _move(ring, matrix): a, b, c, d, e, f = matrix return [(a * x + c * y + e, b * x + d * y + f) for x, y in ring] class _Placed(object): """Crane place : silhouette et encre en coordonnees du document.""" def __init__(self, placement, step): outline, rings = _flat_skull(step) matrix = placement_matrix(*placement) self.placement = placement self.body = _move(outline, matrix) if placement[4]: # Le miroir inverse le sens de parcours : on le retablit. self.body.reverse() self.box = _ring_bbox(self.body) self.ink = [_move(ring, matrix) for ring in rings] def visible_skulls(placements, region, step=0.01, progress=None): """Encre visible de chaque crane : [(placement, anneaux pair-impair)]. `placements` est dans l'ordre de dessin (du dessous vers le dessus). Un crane entierement cache n'apparait pas. `progress(k, total)`, s'il est donne, est appele apres chaque crane. """ from boolean_ops import boolean skulls = [_Placed(p, step) for p in placements] # Index des silhouettes par cases, pour trouver vite celles du dessus. cell = max((max(s.box[2] - s.box[0], s.box[3] - s.box[1]) for s in skulls), default=1.0) grid = {} for k, s in enumerate(skulls): for i in range(int(math.floor(s.box[0] / cell)), int(math.floor(s.box[2] / cell)) + 1): for j in range(int(math.floor(s.box[1] / cell)), int(math.floor(s.box[3] / cell)) + 1): grid.setdefault((i, j), []).append(k) result = [] for k, skull in enumerate(skulls): above = set() box = skull.box for i in range(int(math.floor(box[0] / cell)), int(math.floor(box[2] / cell)) + 1): for j in range(int(math.floor(box[1] / cell)), int(math.floor(box[3] / cell)) + 1): for other in grid.get((i, j), ()): if other > k and _boxes_overlap(box, skulls[other].box): above.add(other) covers = [skulls[o] for o in sorted(above)] border = region.grid.touches(box) if not border and not region.contains(skull.body[0]): # Loin du bord et dehors : entierement hors de la forme. if progress: progress(k + 1, len(skulls)) continue if not covers and not border: # Ni recouvert ni au bord : toute l'encre est visible. result.append((skull.placement, list(skull.ink))) if progress: progress(k + 1, len(skulls)) continue # Partie visible de la silhouette : petit polygone, vite calcule. # Vide, le crane est entierement cache. sets = [([skull.body], "nonzero"), ([c.body for c in covers], "nonzero")] if border: sets.append((region.rings, "evenodd")) shown = boolean(sets, lambda inside: inside[0] and not inside[1] and inside[2]) else: shown = boolean(sets, lambda inside: inside[0] and not inside[1]) kept = [] if shown: # Les anneaux d'encre loin du bord de cette partie visible sont # gardes ou ecartes d'un coup ; les autres sont intersectes avec # elle (l'intersection se distribue sur le OU exclusif). edges = _EdgeGrid(shown) work = [] for ring in skull.ink: ring_box = _ring_bbox(ring) if edges.touches(ring_box): work.append(ring) elif point_in_rings(ring[0], shown): kept.append(ring) if work: kept.extend(boolean([(work, "evenodd"), (shown, "evenodd")], lambda inside: inside[0] and inside[1])) if kept: result.append((skull.placement, kept)) if progress: progress(k + 1, len(skulls)) return result def visible_gaps(placements, region, step=0.01): """Interstices : la forme moins l'union des silhouettes des cranes.""" from boolean_ops import boolean bodies = [_Placed(p, step).body for p in placements] return boolean([(region.rings, "evenodd"), (bodies, "nonzero")], lambda inside: inside[0] and not inside[1]) # -------------------------------------------------------------------------- # Placement # -------------------------------------------------------------------------- def random_size(rng, size_min, size_max, exponent=3.0): """Taille tiree selon une loi de puissance tronquee sur [min, max]. Densite proportionnelle a s^-exponent : beaucoup de petits cranes, peu de grands ; avec 3, chaque octave de tailles couvre une surface comparable, comme dans le motif de reference. """ if size_max <= size_min: return size_min k = 1.0 - exponent lo, hi = size_min ** k, size_max ** k return (lo + rng.random() * (hi - lo)) ** (1.0 / k) def estimate_count(rings, size_min, spacing): """Nombre de positions candidates (pour refuser un calcul demesure).""" box = rings_bbox(rings) if box is None or size_min <= 0 or spacing <= 0: return 0 step = size_min * spacing return int(((box[2] - box[0]) / step + 2) * ((box[3] - box[1]) / step + 2)) def skull_placements(rings, size_min, size_max, spacing=0.7, max_rotation=30.0, mirror=True, seed=1, origin=(0.0, 0.0)): """Positions des cranes couvrant la region. Une grille, de pas `spacing` x taille minimale, decalee une ligne sur deux et secouee au hasard, donne une position par case : la couverture est assuree par les petits cranes. Chaque position recoit une taille (loi de puissance), un angle dans [-max_rotation, max_rotation] et un miroir aleatoire. On ne garde que les cranes qui touchent la region. `origin` cale la grille (origine du document par defaut) : deux formes voisines remplies avec la meme graine partagent les memes positions. Renvoie des tuples (x, y, taille, angle, miroir), du plus petit au plus grand : dessines dans cet ordre, les grands cranes passent devant. """ box = rings_bbox(rings) if box is None or size_min <= 0: return [] size_max = max(size_max, size_min) step = size_min * spacing if step <= 0: return [] row_h = step * 0.866 margin = size_max * skull_radius() x0, y0, x1, y1 = box[0] - margin, box[1] - margin, box[2] + margin, box[3] + margin j_start = int(math.floor((y0 - origin[1]) / row_h)) j_end = int(math.ceil((y1 - origin[1]) / row_h)) i_start = int(math.floor((x0 - origin[0]) / step)) - 1 i_end = int(math.ceil((x1 - origin[0]) / step)) + 1 result = [] for j in range(j_start, j_end + 1): for i in range(i_start, i_end + 1): # Une graine par case : le tirage ne depend pas de l'etendue de la # region, donc pas de la forme remplie. rng = random.Random((seed * 73856093) ^ (i * 19349663) ^ (j * 83492791)) x = origin[0] + (i + 0.5 * (j % 2) + (rng.random() - 0.5) * 0.6) * step y = origin[1] + (j + (rng.random() - 0.5) * 0.6) * row_h size = random_size(rng, size_min, size_max) angle = (rng.random() * 2.0 - 1.0) * max_rotation flip = mirror and rng.random() < 0.5 if not (x0 <= x <= x1 and y0 <= y <= y1): continue # Un crane tient dans un disque de rayon skull_radius() x taille. if not point_in_rings((x, y), rings) and \ distance_to_rings((x, y), rings) > skull_radius() * size: continue result.append((x, y, size, angle, flip)) result.sort(key=lambda p: p[2]) return result