169 lines
6.1 KiB
Python
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())
|