Files
inkscape.motif.skull/docs/extraire_crane.py
T

169 lines
6.1 KiB
Python

#!/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())