Version initiale de l'extension Inkscape de remplissage tête de mort
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
e3383d0caa
25 files changed
+3746
No files matched your search
@@ -0,0 +1,168 @@
|
||||
#!/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())
|
||||
Reference in new issue
Block a user