#!/usr/bin/env python3 # coding=utf-8 """ Extrait le crane du dessin de reference doc/dessin.svg, sans ses cornes, et l'ecrit dans skull_drawing.py (donnees du noyau, sans inkex). python docs/extraire_crane.py Necessite inkex (PYTHONPATH vers les extensions d'Inkscape) : il sert a lire le chemin et a le convertir en courbes de Bezier absolues. Le noyau, lui, ne lit que les chaines produites. Le dessin est un seul chemin noir (regle non nulle) : - le sous-chemin 0 est le contour exterieur du crane et des cornes ; - le sous-chemin 33 borde l'interieur blanc du crane ; a droite, il contourne la base sombre de la corne ; - les sous-chemins 47 a 62 sont les reflets des cornes. Pour retirer les cornes, on remplace les portions du contour exterieur qui les dessinent par un arc qui prolonge la calotte, on referme l'interieur blanc par un arc qui laisse a droite une ombre en croissant s'affinant vers le sommet, et on supprime les reflets. Le contour exterieur sert aussi de silhouette : rempli de la couleur de l'os, il cache les cranes du dessous. """ import math import os import sys import inkex HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) SOURCE = os.path.join(ROOT, "doc", "dessin.svg") TARGET = os.path.join(ROOT, "skull_drawing.py") OUTER, INNER = 0, 33 HORN_DETAILS = range(47, 63) # Centre de la calotte (unites du dessin), autour duquel tournent les arcs. CENTER = (218.0, 168.0) # (sous-chemin, premier noeud garde, noeud de reprise) : les noeuds entre les # deux sont remplaces par un arc. Indices releves sur le dessin. CUTS = [ (OUTER, 20, 36), # corne gauche (OUTER, 39, 56), # corne droite (INNER, 70, 87), # base sombre de la corne droite ] def segments(sub): """Sous-chemin inkex (CubicSuperPath) -> segments (p0, c1, c2, p3).""" return [(tuple(a[1]), tuple(a[2]), tuple(b[0]), tuple(b[1])) for a, b in zip(sub, sub[1:])] def polar(point): dx, dy = point[0] - CENTER[0], point[1] - CENTER[1] return math.hypot(dx, dy), math.atan2(dy, dx) def arc(start, end, max_step=math.radians(15)): """Arc de `start` a `end` autour de CENTER, rayon interpole lineairement.""" r0, a0 = polar(start) r1, a1 = polar(end) # Plus court chemin angulaire. while a1 - a0 > math.pi: a1 -= 2 * math.pi while a0 - a1 > math.pi: a1 += 2 * math.pi count = max(1, int(math.ceil(abs(a1 - a0) / max_step))) result = [] for k in range(count): ta, tb = k / count, (k + 1) / count aa, ab = a0 + ta * (a1 - a0), a0 + tb * (a1 - a0) ra, rb = r0 + ta * (r1 - r0), r0 + tb * (r1 - r0) h = 4.0 / 3.0 * math.tan((ab - aa) / 4.0) pa = (CENTER[0] + ra * math.cos(aa), CENTER[1] + ra * math.sin(aa)) pb = (CENTER[0] + rb * math.cos(ab), CENTER[1] + rb * math.sin(ab)) ca = (pa[0] - h * ra * math.sin(aa), pa[1] + h * ra * math.cos(aa)) cb = (pb[0] + h * rb * math.sin(ab), pb[1] - h * rb * math.cos(ab)) result.append((pa, ca, cb, pb)) # Raccords exacts aux noeuds conserves. first, last = result[0], result[-1] result[0] = (start,) + first[1:] result[-1] = last[:3] + (end,) return result def cut(segs, keep, resume): """Remplace les segments entre les noeuds `keep` et `resume` par un arc.""" return segs[:keep] + arc(segs[keep][0], segs[resume][0]) + segs[resume:] def to_d(loops, transform, precision=4): fmt = "{:.%df},{:.%df}" % (precision, precision) def pt(p): return fmt.format(*transform(p)) parts = [] for loop in loops: parts.append("M " + pt(loop[0][0])) parts.extend("C {} {} {}".format(pt(c1), pt(c2), pt(p3)) for _p0, c1, c2, p3 in loop) parts.append("Z") return " ".join(parts) def main(): document = inkex.load_svg(SOURCE).getroot() path = document.getElementById("path1") csp = path.path.transform(path.composed_transform()).to_superpath() subs = {k: segments(sub) for k, sub in enumerate(csp)} # Les coupes d'un meme sous-chemin se font de la fin vers le debut, pour # que les indices des noeuds restent valables. for index, keep, resume in sorted(CUTS, key=lambda c: -c[1]): subs[index] = cut(subs[index], keep, resume) for index in HORN_DETAILS: del subs[index] body = [subs[OUTER]] ink = [subs[k] for k in sorted(subs)] # Repere unite : centre du cadre en (0, 0), hauteur 1. xs = [p[0] for seg in body[0] for p in seg] ys = [p[1] for seg in body[0] for p in seg] cx, cy = (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2 height = max(ys) - min(ys) def unit(p): return ((p[0] - cx) / height, (p[1] - cy) / height) with open(TARGET, "w", encoding="utf-8", newline="\n") as handle: handle.write('# coding=utf-8\n"""\nDessin du crane integre, genere par docs/extraire_crane.py ' "a partir de\ndoc/dessin.svg (cornes retirees). Ne pas modifier a la main.\n\n" "Repere unite : centre du cadre en (0, 0), hauteur 1, y vers le bas.\n" "BODY_D : silhouette (remplie de la couleur de l'os) ;\n" "INK_D : trait et ombres, un seul chemin en regle non nulle.\n" '"""\n\n') handle.write("WIDTH = {:.4f}\n\n".format((max(xs) - min(xs)) / height)) handle.write("BODY_D = (\n") for chunk in wrap(to_d(body, unit)): handle.write(" {!r}\n".format(chunk)) handle.write(")\n\nINK_D = (\n") for chunk in wrap(to_d(ink, unit)): handle.write(" {!r}\n".format(chunk)) handle.write(")\n") print("{} : {} sous-chemins d'encre".format(TARGET, len(ink))) def wrap(text, width=90): """Decoupe une chaine en morceaux d'au plus `width` caracteres, sur les espaces.""" chunks, line = [], "" for word in text.split(" "): if line and len(line) + 1 + len(word) > width: chunks.append(line + " ") line = word else: line = word if not line else line + " " + word if line: chunks.append(line) return chunks if __name__ == "__main__": sys.exit(main())