commit e3383d0caa8a3e10c1da19ccc886a1af1212cf9b Author: Alex Date: Tue Nov 17 19:01:43 2026 +0100 Version initiale de l'extension Inkscape de remplissage tête de mort Co-Authored-By: Claude Opus 5.5 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8aa9a2d --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +# Cache Python et outils +__pycache__/ +*.pyc +.pytest_cache/ +.venv/ + +# Archives de distribution +*.zip + +# SVG intermediaires du schema (regeneres par docs/schema_parametres.py) +docs/*.svg + +# Page de presentation : hors depot (publiee sur le NAS par site/deploy.ps1 ; +# sa configuration contient hote, compte et chemin de cle SSH) +site/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..181057d --- /dev/null +++ b/README.md @@ -0,0 +1,246 @@ +# Remplissage têtes de mort — extension Inkscape + + + + + + +
+Cœur rempli de têtes de mort de tailles variées, inclinées et superposées, coupées au contour + + +Extension Inkscape 1.x qui remplit une forme de têtes de mort, à la manière du +motif [`doc/patern.png`](doc/patern.png) : un même crâne répété à des tailles, +des angles et en miroir différents, empilé sans laisser de vide. Les petits +crânes tapissent le fond, les grands passent par-dessus, et le tout est +découpé au contour de la forme. Le crâne est le dessin vectoriel +[`doc/dessin.svg`](doc/dessin.svg), sans ses cornes : vu de trois quarts, +arêtes vives, mâchoire en équerre, sutures et ombre sur la tempe. + +Le résultat est prévu pour la **gravure laser** : il ne contient que l'encre +réellement visible. Les traits cachés par les crânes du dessus sont supprimés, +les crânes du bord sont coupés, et aucun masque, clone ni objet blanc n'est +écrit : le laser ne grave rien de caché. + +
+ +## Sommaire + +- [Fonctionnalités](#fonctionnalités) +- [Installation](#installation) +- [Utilisation](#utilisation) +- [Paramètres](#paramètres) +- [Structure du projet](#structure-du-projet) +- [Développement](#développement) + +## Fonctionnalités + +- Remplit chemins, rectangles, cercles, ellipses et polygones, y compris les + formes trouées (règle pair-impair) ; un groupe sélectionné est rempli forme + par forme. Textes et images sont ignorés. +- Tailles tirées selon une loi de puissance entre la plus petite et la plus + grande : beaucoup de petits crânes, quelques grands, dessinés du plus petit + au plus grand pour que les grands passent devant. +- Grille décalée et secouée au hasard, inclinaison aléatoire bornée, miroir + aléatoire ; une graine change la disposition, et deux formes voisines + remplies avec la même graine partagent les mêmes positions (grille calée sur + l'origine du document). +- Prêt pour la gravure laser : seule l'encre visible est écrite. Pour chaque + crâne, son trait, limité à la forme, moins les silhouettes des crânes posés + au-dessus ; les crânes entièrement cachés disparaissent. Les interstices + (la forme moins toutes les silhouettes) peuvent prendre la couleur de + l'encre, comme les ombres du motif de référence. +- Que des chemins pleins, en règle pair-impair, qui ne se recouvrent pas : + ni masque (`clipPath`), ni clone (``), ni objet blanc. +- Opérations booléennes (différence, intersection, union) par un balayage + écrit en Python pur (`boolean_ops.py`), sans dépendance. +- Environ 5 s pour 100 crânes : 30 s et 600 Ko pour un cœur de 190 mm garni + de 640 crânes (350 visibles). +- Unités réelles (mm, cm, px, pt, in), justes même sur une page redimensionnée. +- Interface traduite en français et en anglais, selon la langue d'Inkscape + (anglais pour toute autre langue). +- Script de déploiement Windows (`deploy.ps1`). + +## Installation + +Aucune dépendance externe : l'extension utilise `inkex`, fourni avec Inkscape. + +### Windows (script) + +Inkscape fermé : + +```powershell +.\deploy.ps1 # installe ou met à jour +.\deploy.ps1 -Uninstall # désinstalle +.\deploy.ps1 -Force # déploie même si Inkscape est ouvert +``` + +Les fichiers sont copiés dans `%APPDATA%\inkscape\extensions\skullFill`. + +### Manuelle + +Copier dans un sous-dossier du répertoire des extensions utilisateur : + +- `skull_fill.inx`, `skull_fill.py`, `skull_fill_core.py`, `skull_drawing.py` ; +- `images/parameters_en.png` ; +- `locale/` (traductions compilées). + +| Système | Répertoire des extensions | +| ------- | -------------------------------------------------- | +| Windows | `%APPDATA%\inkscape\extensions` | +| Linux | `~/.config/inkscape/extensions` | +| macOS | `~/Library/Application Support/org.inkscape.Inkscape/config/inkscape/extensions` | + +Redémarrer Inkscape. + +## Utilisation + +1. Sélectionner une ou plusieurs formes. +2. **Extensions > AlexDesign > Remplissage têtes de mort…** (*Skull Pattern Fill*). +3. Régler les onglets **Crânes** et **Style**, puis **Appliquer**. + +Le résultat est un groupe « Remplissage têtes de mort » placé juste au-dessus +de chaque forme : un chemin par crâne visible, plus les interstices. Pour la +gravure, garder la forme d'origine seulement si son contour doit être gravé +ou découpé. + +**Conseils** + +| Symptôme | Réglage | +| ------------------------------------- | -------------------------------------------------------- | +| Des vides apparaissent | Baisser l'espacement (70 % par défaut) ou cocher *Remplir les interstices* | +| Trop de crânes, calcul refusé | Augmenter la plus petite hauteur ou l'espacement | +| Calcul long, fichier lourd | Augmenter la plus petite hauteur ou l'espacement : moins de crânes | +| Motif trop régulier | Écarter les deux hauteurs, augmenter l'inclinaison | +| La disposition ne plaît pas | Changer la graine aléatoire | + +## Paramètres + +![Schéma des paramètres](docs/parametres.png) + +| Paramètre | Défaut | Rôle | +| ------------------------------------------- | ----------- | ---- | +| Hauteur du plus grand crâne | 30 | Taille maximale tirée | +| Hauteur du plus petit crâne | 10 | Taille minimale ; fixe aussi le pas de la grille | +| Unité | mm | mm, cm, px, pt, in | +| Espacement (% de la plus petite hauteur) | 70 | Pas de la grille ; sous 100 %, les crânes se chevauchent | +| Inclinaison maximale (°) | 30 | Angle tiré entre -max et +max | +| Retourner des crânes en miroir au hasard | oui | Environ un crâne sur deux retourné | +| Graine aléatoire | 1 | Autre valeur, autre disposition | +| Couleur de l'encre | noir | Couleur de tout ce qui est écrit (trait, ombres, interstices) | +| Remplir les interstices de la couleur de l'encre | oui | Fond de la forme sous les crânes | +| Conserver la forme d'origine | oui | Sinon, la forme est supprimée | + +## Structure du projet + +```text +skull_fill.inx Boîte de dialogue (textes source en anglais) +skull_fill.py Couche inkex : sélection, unités, écriture des chemins +skull_fill_core.py Logique pure, sans inkex : crâne, placements, encre visible +boolean_ops.py Opérations booléennes sur polygones (balayage, Python pur) +skull_drawing.py Données du crâne (générées par docs/extraire_crane.py) +docs/extraire_crane.py Extraction du crâne de doc/dessin.svg, cornes retirées +i18n.py Extraction / mise à jour / compilation des traductions +po/ skullfill.pot, en.po, fr.po +locale/ Catalogues .mo compilés (déployés) +images/parameters_en.png Schéma de l'onglet « Help » +docs/schema_parametres.py Générateur du schéma (fr pour le README, en pour le dialogue) +docs/parametres.png Schéma du README +docs/capture-desktop.png Rendu d'exemple +doc/patern.png Motif de référence (disposition des crânes) +doc/dessin.svg Dessin vectoriel du crâne (avec cornes, retirées à l'extraction) +tests/data/ Formes d'exemple (shapes.svg, scaled.svg) +test_skull_fill.py Tests pytest +deploy.ps1 Déploiement Windows +``` + +API du noyau `skull_fill_core` : + +| Fonction | Rôle | +| -------- | ---- | +| `skull_geometry()` | Le crâne dans son repère unité : (silhouette, encre), listes de boucles de Bézier | +| `skull_paths(placement, precision=3)` | Données `d` (silhouette, encre) d'un crâne placé | +| `parse_loops(d)` | Chemin SVG en M, C, Z absolus → boucles de Bézier | +| `Region(rings)` | Forme à remplir (pair-impair) : `contains(point)` | +| `visible_skulls(placements, region, step=0.01)` | Encre visible de chaque crâne : `[(placement, anneaux)]`, crânes cachés omis | +| `visible_gaps(placements, region, step=0.01)` | Interstices : la forme moins l'union des silhouettes | +| `skull_radius()` | Rayon du disque contenant le crâne, pour une hauteur 1 | +| `flatten_loops(loops, matrix, step)` | Boucles de Bézier → polygones | +| `simplify_ring(ring, tolerance)` | Simplification de Douglas-Peucker | +| `rings_to_d(rings, precision=2)` | Chemin compact (M, l relatifs, z) | +| `ring_area(ring)` | Aire signée d'un anneau | +| `skull_placements(rings, size_min, size_max, spacing=0.7, max_rotation=30, mirror=True, seed=1, origin=(0, 0))` | Tuples `(x, y, taille, angle, miroir)` couvrant la région, du plus petit au plus grand | +| `placement_matrix(x, y, size, angle=0, mirror=False)` | Matrice affine du repère unité vers le document | +| `loops_to_d(loops, matrix, precision=3)` | Chemin SVG (M, C, Z absolus) de boucles transformées | +| `random_size(rng, size_min, size_max, exponent=3)` | Taille selon une loi de puissance tronquée | +| `estimate_count(rings, size_min, spacing)` | Nombre de positions candidates | +| `point_in_rings(point, rings)`, `distance_to_rings(point, rings)`, `rings_bbox(rings)` | Géométrie de la région (pair-impair) | +| `parse_color(value)` | Couleur Inkscape → (`#rrggbb`, opacité) | + +Moteur `boolean_ops` : `boolean(ensembles, prédicat)` combine des ensembles +`(anneaux, règle)` (`"evenodd"` ou `"nonzero"`) selon un prédicat sur +l'appartenance à chacun ; `union`, `intersection` et `difference` en sont des +raccourcis. Résultat : des anneaux à remplir en pair-impair. Les points sont +calés sur une grille de 1e-6 ; deux polygones aux côtés exactement confondus +sont gérés, mais pas des côtés décalés de moins de 1e-5 (cas absent des +crânes). + +## Développement + +```powershell +python -m venv .venv +.venv\Scripts\activate +pip install pytest lxml tinycss2 cssselect2 cssselect +python -m pytest -q +``` + +Sans inkex : 32 tests passés, 6 ignorés (bout en bout). Avec inkex : + +```powershell +$env:PYTHONPATH = 'C:\Program Files\Inkscape\share\inkscape\extensions' +python -m pytest -q # 38 tests passés (environ 30 s) +``` + +Les tests couvrent le crâne (repère unité, encre dans le cadre, boucles fermées, +absence de cornes, vue de trois quarts), la lecture et l'écriture des chemins, +le moteur booléen (opérations de base, côtés communs, règle non nulle, trous, +différences aléatoires vérifiées par échantillonnage), l'encre visible (aucun +point sous un crâne du dessus ni hors de la forme, crâne du dessus entier, +crâne caché ou hors forme omis, interstices), les placements (couverture, +ordre, bornes d'angle, miroir, trous, reproductibilité), le bout en bout (ni +masque, ni clone, ni blanc, tout dans la forme, trou laissé vide, couleur, +interstices, groupes, échelle de document non standard, garde-fou du nombre +de crânes) et la cohérence `.inx` ↔ arguments ↔ traductions. + +### Traductions + +```powershell +python i18n.py # extrait, met à jour po/*.po, compile locale/*.mo +``` + +Après modification d'un texte (`.inx` ou `_("...")`) : lancer `python i18n.py`, +compléter les `msgstr` vides de `po/fr.po`, relancer. Pour ajouter une langue, +l'ajouter à `LANGUAGES` dans `i18n.py`. + +### Dessin du crâne + +```powershell +$env:PYTHONPATH = 'C:\Program Files\Inkscape\share\inkscape\extensions' +python docs/extraire_crane.py # doc/dessin.svg -> skull_drawing.py +``` + +Le script lit le chemin unique de `doc/dessin.svg`, remplace les cornes par +un arc qui prolonge la calotte, supprime leurs reflets et ramène le dessin au +repère unité du noyau. Après une retouche du dessin dans Inkscape, vérifier +les indices de nœuds notés en tête du script (`CUTS`, `HORN_DETAILS`), puis +relancer le script, les tests et le schéma. + +### Schéma des paramètres + +```powershell +python docs/schema_parametres.py # docs/parametres.png (fr) + images/parameters_en.png (en) +``` + +Le schéma est dessiné avec les fonctions du noyau, puis exporté par +`C:\Program Files\Inkscape\bin\inkscape.com`. La version anglaise est celle de +l'onglet « Help » : Inkscape ne traduit pas le chemin d'une image. diff --git a/boolean_ops.py b/boolean_ops.py new file mode 100644 index 0000000..0489fe3 --- /dev/null +++ b/boolean_ops.py @@ -0,0 +1,411 @@ +# coding=utf-8 +""" +Operations booleennes sur des polygones, en Python pur (sans inkex). + +Sert a ne garder que l'encre reellement visible des cranes : une decoupeuse +laser grave tout trait present dans le fichier, meme cache sous un autre +objet. Il faut donc calculer la geometrie visible (difference, intersection, +union) au lieu de laisser les cranes du dessus masquer ceux du dessous. + +Principe (balayage de Bentley-Ottmann, a la maniere de PolyBool de Sean +Connelly) : tous les cotes des polygones sont balayes de gauche a droite ; +chaque croisement coupe les cotes concernes ; chaque morceau connait alors, +pour chaque ensemble d'entree, le nombre d'enroulement juste au-dessus et +juste au-dessous de lui. Un predicat dit si un point est dans le resultat +selon son appartenance a chaque ensemble ; on garde les morceaux qui +separent un cote « dedans » d'un cote « dehors », puis on les enchaine en +anneaux fermes. + +Conventions : +- un anneau est une liste de points (x, y), ferme implicitement ; +- un ensemble est (anneaux, regle), regle valant "evenodd" ou "nonzero" ; +- le resultat est une liste d'anneaux a remplir en regle pair-impair. +""" + +import heapq + +# Tous les points (sommets d'entree et croisements) sont cales sur une +# grille de pas GRID : deux points sont confondus s'ils sont egaux, et +# l'ordre de balayage est une simple comparaison de nombres. EPS sert aux +# produits vectoriels (alignements), EPS_T a la position le long d'un +# segment. +GRID = 1e-6 +EPS = 1e-10 +EPS_T = 1e-9 +# Un croisement plus proche que SNAP d'une extremite est rabattu sur elle : +# sans cela, deux croisements presque confondus creent des segments de +# quelques millioniemes que les tests d'alignement jugent mal. +SNAP = 1e-5 + + +def snap(p): + return (round(p[0] / GRID) * GRID, round(p[1] / GRID) * GRID) + + +def _compare(a, b): + """Ordre de balayage : x croissant, puis y croissant.""" + if a == b: + return 0 + return -1 if a < b else 1 + + +def _same(a, b): + return a == b + + +def _near(a, b): + return abs(a[0] - b[0]) < SNAP and abs(a[1] - b[1]) < SNAP + + +def _above_or_on(pt, left, right): + return ((right[0] - left[0]) * (pt[1] - left[1]) + - (right[1] - left[1]) * (pt[0] - left[0])) >= -EPS + + +def _collinear(a, b, c): + return abs((a[0] - b[0]) * (b[1] - c[1]) - (b[0] - c[0]) * (a[1] - b[1])) < EPS + + +def _between(p, left, right): + """p (aligne sur left-right) est-il strictement entre les deux ?""" + dpx, dpy = p[0] - left[0], p[1] - left[1] + drx, dry = right[0] - left[0], right[1] - left[1] + dot = dpx * drx + dpy * dry + if dot < EPS: + return False + return dot - (drx * drx + dry * dry) <= -EPS + + +def _along(v): + """Position d'un parametre sur un segment : -2 avant, -1 au debut, + 0 dedans, 1 a la fin, 2 apres.""" + if v <= -EPS_T: + return -2 + if v < EPS_T: + return -1 + if v - 1 <= -EPS_T: + return 0 + if v - 1 < EPS_T: + return 1 + return 2 + + +def _lines_intersect(a0, a1, b0, b1): + adx, ady = a1[0] - a0[0], a1[1] - a0[1] + bdx, bdy = b1[0] - b0[0], b1[1] - b0[1] + axb = adx * bdy - ady * bdx + if abs(axb) < EPS: + return None + dx, dy = a0[0] - b0[0], a0[1] - b0[1] + a = (bdx * dy - bdy * dx) / axb + b = (adx * dy - ady * dx) / axb + return _along(a), _along(b), snap((a0[0] + a * adx, a0[1] + a * ady)) + + +class _Segment(object): + __slots__ = ("start", "end", "delta", "below", "above") + + def __init__(self, start, end, delta): + self.start, self.end, self.delta = start, end, delta + self.below = self.above = None + + +class _Event(object): + __slots__ = ("is_start", "pt", "seg", "other", "entry") + + def __init__(self, is_start, pt, seg): + self.is_start, self.pt, self.seg = is_start, pt, seg + self.other = None + self.entry = None + + +class _Tie(object): + """Departage de deux evenements au meme point (cle figee a l'insertion).""" + __slots__ = ("is_start", "p1", "p2") + + def __init__(self, ev): + self.is_start, self.p1, self.p2 = ev.is_start, ev.pt, ev.other.pt + + def compare(self, other): + if self.p2 == other.p2: + return 0 + if self.is_start != other.is_start: + # A meme point, les fins passent avant les debuts. + return 1 if self.is_start else -1 + if other.is_start: + return 1 if _above_or_on(self.p2, other.p1, other.p2) else -1 + return 1 if _above_or_on(self.p2, other.p2, other.p1) else -1 + + def __lt__(self, other): + return self.compare(other) < 0 + + def __eq__(self, other): + return self.compare(other) == 0 + + +def _status_compare(ev1, ev2): + a1, a2 = ev1.seg.start, ev1.seg.end + b1, b2 = ev2.seg.start, ev2.seg.end + if _collinear(a1, b1, b2): + if _collinear(a2, b1, b2): + return 1 + return 1 if _above_or_on(a2, b1, b2) else -1 + return 1 if _above_or_on(a1, b1, b2) else -1 + + +class _Sweep(object): + + def __init__(self, count): + self.count = count + self.heap = [] + self.serial = 0 + self.status = [] + + # -- file des evenements (tas, suppressions paresseuses) --------------- + + def push(self, ev): + self.serial += 1 + ev.entry = self.serial + # Le point d'abord (comparaison rapide), le departage ensuite. + heapq.heappush(self.heap, (ev.pt, _Tie(ev), self.serial, ev)) + + def head(self): + heap = self.heap + while heap and heap[0][3].entry != heap[0][2]: + heapq.heappop(heap) + return heap[0][3] if heap else None + + def add_segment(self, seg): + start = _Event(True, seg.start, seg) + end = _Event(False, seg.end, seg) + start.other, end.other = end, start + self.push(start) + self.push(end) + return start + + def update_end(self, ev, pt): + ev.other.entry = None + ev.seg.end = pt + ev.other.pt = pt + self.push(ev.other) + + def divide(self, ev, pt): + # La coupe doit tomber strictement entre les extremites, dans l'ordre + # du balayage, sinon elle retournerait un morceau. + if not (ev.seg.start < pt < ev.seg.end): + return None + piece = _Segment(pt, ev.seg.end, list(ev.seg.delta)) + self.update_end(ev, pt) + return self.add_segment(piece) + + def add_ring(self, ring, index): + ring = [snap(p) for p in ring] + n = len(ring) + for i in range(n): + p1, p2 = ring[i - 1], ring[i] + forward = _compare(p1, p2) + if forward == 0: + continue + delta = [0] * self.count + # Le sens d'origine du cote donne le signe de l'enroulement. + delta[index] = 1 if forward < 0 else -1 + if forward < 0: + self.add_segment(_Segment(p1, p2, delta)) + else: + self.add_segment(_Segment(p2, p1, delta)) + + # -- croisements -------------------------------------------------------- + + def check(self, ev1, ev2): + """Coupe ev1 et ev2 a leur croisement ; renvoie ev2 s'ils sont confondus.""" + a1, a2 = ev1.seg.start, ev1.seg.end + b1, b2 = ev2.seg.start, ev2.seg.end + cross = _lines_intersect(a1, a2, b1, b2) + if cross is None: + # Paralleles : seul le cas aligne et chevauchant compte. + if not _collinear(a1, a2, b1): + return None + if _same(a1, b2) or _same(a2, b1): + return None + a1_b1, a2_b2 = _same(a1, b1), _same(a2, b2) + if a1_b1 and a2_b2: + return ev2 + a1_between = not a1_b1 and _between(a1, b1, b2) + a2_between = not a2_b2 and _between(a2, b1, b2) + if a1_b1: + if a2_between: + self.divide(ev2, a2) + else: + self.divide(ev1, b2) + return ev2 + if a1_between: + if not a2_b2: + if a2_between: + self.divide(ev2, a2) + else: + self.divide(ev1, b2) + self.divide(ev2, a1) + return None + along_a, along_b, pt = cross + # Croisement confondu avec un sommet : on le rabat sur ce sommet. + if along_a == 0: + if _near(pt, a1): + along_a = -1 + elif _near(pt, a2): + along_a = 1 + if along_b == 0: + if _near(pt, b1): + along_b, pt = -1, b1 + elif _near(pt, b2): + along_b, pt = 1, b2 + if along_a == -1: + pt = a1 + elif along_a == 1: + pt = a2 + if along_a == 0: + if along_b == -1: + self.divide(ev1, b1) + elif along_b == 0: + self.divide(ev1, pt) + elif along_b == 1: + self.divide(ev1, b2) + if along_b == 0: + if along_a == -1: + self.divide(ev2, a1) + elif along_a == 0: + self.divide(ev2, pt) + elif along_a == 1: + self.divide(ev2, a2) + return None + + # -- balayage ----------------------------------------------------------- + + def run(self): + status = self.status + result = [] + zero = [0] * self.count + while True: + ev = self.head() + if ev is None: + break + if ev.is_start: + index = len(status) + for i, here in enumerate(status): + if _status_compare(ev, here) > 0: + index = i + break + above = status[index - 1] if index > 0 else None + below = status[index] if index < len(status) else None + same = self.check(ev, above) if above is not None else None + if same is None and below is not None: + same = self.check(ev, below) + if same is not None: + # Cotes confondus : un seul morceau, enroulements cumules. + # `same` est deja dans le statut : son enroulement au-dessus + # change aussi. + for k, d in enumerate(ev.seg.delta): + same.seg.delta[k] += d + if same.seg.above is not None: + same.seg.above[k] += d + ev.entry = None + ev.other.entry = None + if self.head() is not ev: + continue + base = below.seg.above if below is not None else zero + ev.seg.below = list(base) + ev.seg.above = [b + d for b, d in zip(base, ev.seg.delta)] + status.insert(index, ev) + ev.entry = None + else: + start = ev.other + i = status.index(start) + if 0 < i < len(status) - 1: + self.check(status[i - 1], status[i + 1]) + del status[i] + result.append(ev.seg) + ev.entry = None + return result + + +def _inside(winding, rule): + return (winding % 2 == 1) if rule == "evenodd" else (winding != 0) + + +def _chain(segments): + """Morceaux de frontiere -> anneaux fermes.""" + def key(p): + return (round(p[0] * 1e6), round(p[1] * 1e6)) + + ends = {} + for i, seg in enumerate(segments): + ends.setdefault(key(seg.start), []).append(i) + ends.setdefault(key(seg.end), []).append(i) + used = [False] * len(segments) + rings = [] + for i, seg in enumerate(segments): + if used[i]: + continue + used[i] = True + ring = [seg.start] + first = key(seg.start) + point = seg.end + while key(point) != first: + ring.append(point) + nxt = None + for j in ends.get(key(point), ()): + if not used[j]: + nxt = j + break + if nxt is None: + ring = None + break + used[nxt] = True + other = segments[nxt] + point = other.end if key(other.start) == key(point) else other.start + if ring and len(ring) >= 3: + rings.append(_drop_collinear(ring)) + return [ring for ring in rings if len(ring) >= 3] + + +def _drop_collinear(ring): + result = [] + n = len(ring) + for i in range(n): + a, b, c = ring[i - 1], ring[i], ring[(i + 1) % n] + if not _collinear(a, b, c): + result.append(b) + return result + + +def boolean(sets, predicate): + """Combinaison booleenne de plusieurs ensembles de polygones. + + `sets` : liste de (anneaux, regle) ; `predicate` recoit un tuple de + booleens (le point est-il dans chaque ensemble ?) et dit s'il est dans le + resultat. Renvoie des anneaux a remplir en regle pair-impair. + """ + rules = [rule for _rings, rule in sets] + sweep = _Sweep(len(sets)) + for index, (rings, _rule) in enumerate(sets): + for ring in rings: + if len(ring) >= 3: + sweep.add_ring(ring, index) + kept = [] + for seg in sweep.run(): + below = predicate(tuple(_inside(w, r) for w, r in zip(seg.below, rules))) + above = predicate(tuple(_inside(w, r) for w, r in zip(seg.above, rules))) + if below != above: + kept.append(seg) + return _chain(kept) + + +def union(rings, rule="nonzero"): + return boolean([(rings, rule)], lambda inside: inside[0]) + + +def intersection(a, b, rule_a="evenodd", rule_b="evenodd"): + return boolean([(a, rule_a), (b, rule_b)], lambda inside: inside[0] and inside[1]) + + +def difference(a, b, rule_a="evenodd", rule_b="evenodd"): + return boolean([(a, rule_a), (b, rule_b)], lambda inside: inside[0] and not inside[1]) diff --git a/deploy.ps1 b/deploy.ps1 new file mode 100644 index 0000000..b7f28cc --- /dev/null +++ b/deploy.ps1 @@ -0,0 +1,107 @@ +<# +.SYNOPSIS + Déploie l'extension « Remplissage têtes de mort » dans Inkscape. + +.DESCRIPTION + Copie skull_fill.inx, skull_fill.py, skull_fill_core.py, skull_drawing.py, boolean_ops.py, le schéma de l'onglet + « Help » (images\parameters_en.png) et les traductions + compilées (locale\\LC_MESSAGES\skullfill.mo) dans un + sous-dossier dédié du répertoire des extensions utilisateur d'Inkscape + (Inkscape explore récursivement ce répertoire). Refuse de s'exécuter si + Inkscape est ouvert : les extensions ne sont chargées qu'au démarrage. + +.PARAMETER ExtensionsDir + Répertoire des extensions Inkscape. Par défaut : %APPDATA%\inkscape\extensions + +.PARAMETER FolderName + Nom du sous-dossier de l'extension. Par défaut : skullFill + +.PARAMETER Uninstall + Supprime le sous-dossier de l'extension au lieu de le créer. + +.PARAMETER Force + Déploie même si Inkscape est en cours d'exécution. + +.EXAMPLE + .\deploy.ps1 + .\deploy.ps1 -Uninstall + .\deploy.ps1 -FolderName 'autre-nom' +#> + +[CmdletBinding()] +param( + [string] $ExtensionsDir = (Join-Path $env:APPDATA 'inkscape\extensions'), + [string] $FolderName = 'skullFill', + [switch] $Uninstall, + [switch] $Force +) + +$ErrorActionPreference = 'Stop' + +$files = @('skull_fill.inx', 'skull_fill.py', 'skull_fill_core.py', 'skull_drawing.py', 'boolean_ops.py', 'images\parameters_en.png') +$localeDir = 'locale' +$source = $PSScriptRoot +$destination = Join-Path $ExtensionsDir $FolderName + +# --- Inkscape doit être fermé : les extensions sont lues au démarrage --------- +$running = Get-Process -Name 'inkscape' -ErrorAction SilentlyContinue +if ($running -and -not $Force) { + Write-Error "Inkscape est ouvert. Fermez-le puis relancez le script (ou utilisez -Force)." + exit 1 +} + +# --- Désinstallation --------------------------------------------------------- +if ($Uninstall) { + if (Test-Path -LiteralPath $destination) { + Remove-Item -LiteralPath $destination -Recurse -Force + Write-Host "Supprimé : $destination" -ForegroundColor Green + } + else { + Write-Host "Rien à supprimer : $destination n'existe pas." -ForegroundColor Yellow + } + exit 0 +} + +# --- Vérification des sources ------------------------------------------------ +$missing = $files | Where-Object { -not (Test-Path -LiteralPath (Join-Path $source $_)) } +if (-not (Test-Path -LiteralPath (Join-Path $source $localeDir))) { + $missing = @($missing) + "$localeDir\ (lancer : python i18n.py)" +} +if ($missing) { + Write-Error "Fichier(s) introuvable(s) dans $source : $($missing -join ', ')" + exit 1 +} + +# --- Copie ------------------------------------------------------------------- +if (-not (Test-Path -LiteralPath $destination)) { + New-Item -ItemType Directory -Path $destination -Force | Out-Null + Write-Host "Dossier créé : $destination" +} + +foreach ($file in $files) { + $from = Join-Path $source $file + $to = Join-Path $destination $file + $action = if (Test-Path -LiteralPath $to) { 'remplacé' } else { 'copié ' } + New-Item -ItemType Directory -Path (Split-Path $to) -Force | Out-Null + Copy-Item -LiteralPath $from -Destination $to -Force + Write-Host " $action $file" +} + +# Traductions : le dossier est remplacé en entier (langue retirée => supprimée) +$localeTo = Join-Path $destination $localeDir +if (Test-Path -LiteralPath $localeTo) { + Remove-Item -LiteralPath $localeTo -Recurse -Force +} +Copy-Item -LiteralPath (Join-Path $source $localeDir) -Destination $localeTo -Recurse +$languages = Get-ChildItem -LiteralPath $localeTo -Directory | ForEach-Object Name +Write-Host " copié $localeDir\ ($($languages -join ', '))" + +# Le cache Python d'une version précédente peut masquer les fichiers copiés +$pycache = Join-Path $destination '__pycache__' +if (Test-Path -LiteralPath $pycache) { + Remove-Item -LiteralPath $pycache -Recurse -Force +} + +Write-Host "" +Write-Host "Extension déployée dans $destination" -ForegroundColor Green +Write-Host "Redémarrez Inkscape, puis : Extensions > AlexDesign > Remplissage têtes de mort..." diff --git a/doc/00034-dreamshaper_8_512-512_.png b/doc/00034-dreamshaper_8_512-512_.png new file mode 100644 index 0000000..b6b110f Binary files /dev/null and b/doc/00034-dreamshaper_8_512-512_.png differ diff --git a/doc/dessin.svg b/doc/dessin.svg new file mode 100644 index 0000000..2fd5167 --- /dev/null +++ b/doc/dessin.svg @@ -0,0 +1,42 @@ + + + + diff --git a/doc/patern.png b/doc/patern.png new file mode 100644 index 0000000..32edb71 Binary files /dev/null and b/doc/patern.png differ diff --git a/docs/capture-desktop.png b/docs/capture-desktop.png new file mode 100644 index 0000000..8a6085b Binary files /dev/null and b/docs/capture-desktop.png differ diff --git a/docs/extraire_crane.py b/docs/extraire_crane.py new file mode 100644 index 0000000..d1b9169 --- /dev/null +++ b/docs/extraire_crane.py @@ -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()) diff --git a/docs/parametres.png b/docs/parametres.png new file mode 100644 index 0000000..d74d8ca Binary files /dev/null and b/docs/parametres.png differ diff --git a/docs/schema_parametres.py b/docs/schema_parametres.py new file mode 100644 index 0000000..cfec2be --- /dev/null +++ b/docs/schema_parametres.py @@ -0,0 +1,324 @@ +#!/usr/bin/env python3 +# coding=utf-8 +""" +Genere le schema explicatif des parametres de l'extension. + + python docs/schema_parametres.py # les deux versions + python docs/schema_parametres.py fr # docs/parametres.svg + .png (README) + python docs/schema_parametres.py en # docs/parameters_en.svg + # + images/parameters_en.png (onglet + # « Help » de la boite de dialogue) + +Les formes sont calculees par skull_fill_core (memes fonctions que l'extension), +le schema reste donc fidele au resultat reel. L'export PNG passe par +inkscape.com, qui attend la fin de l'export (contrairement au raccourci +Chocolatey « inkscape »). +""" + +import math +import os +import subprocess +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) +sys.path.insert(0, ROOT) + +import skull_fill_core # noqa: E402,F401 + +W, H = 1400, 1280 # 4 panneaux de 700 x 640 + +INK = "#343a40" # element principal +GHOST = "#dde1e5" # elements secondaires / voisins +DIM = "#d9480f" # cotes +DIM2 = "#1971c2" # cotes secondaires +EDGE = "#212529" # contour des formes +FONT = "font-family:Arial,Helvetica,sans-serif" + +INKSCAPE = [r"C:\Program Files\Inkscape\bin\inkscape.com", "/usr/bin/inkscape", + "/Applications/Inkscape.app/Contents/MacOS/inkscape"] + +# Version par langue : textes, fichiers produits, largeur du PNG et agrandissement +# des textes (la version anglaise est affichee reduite dans la boite de dialogue : +# 900 px de large, textes x 1.25 pour rester lisibles). +VERSIONS = { + "fr": { + "svg": os.path.join(HERE, "parametres.svg"), + "png": os.path.join(HERE, "parametres.png"), + "png_width": 1400, + "font_scale": 1.0, + "text": { + "title1": "Hauteur des crânes", + "note1": ["Tailles tirées entre la plus petite et la plus grande :", + "beaucoup de petits crânes, quelques grands par-dessus."], + "title2": "Espacement", + "note2": ["Pas de la grille, en % de la plus petite hauteur.", + "Sous 100 %, les crânes se chevauchent sans laisser de vide."], + "title3": "Inclinaison et miroir", + "tilt": "max", + "mirror": "miroir", + "note3": ["Angle tiré entre -max et +max ; un crâne sur deux,", + "au hasard, est retourné en miroir."], + "title4": "Résultat", + "note4": ["Seule l'encre visible est écrite : rien de caché", + "ni de masqué, prêt pour la gravure laser."], + }, + }, + "en": { + "svg": os.path.join(HERE, "parameters_en.svg"), + "png": os.path.join(ROOT, "images", "parameters_en.png"), + "png_width": 900, + "font_scale": 1.25, + "text": { + "title1": "Skull height", + "note1": ["Sizes range from the smallest to the largest:", + "many small skulls, a few large ones on top."], + "title2": "Spacing", + "note2": ["Grid step, in % of the smallest height.", + "Below 100 %, skulls overlap and leave no gap."], + "title3": "Tilt and mirror", + "tilt": "max", + "mirror": "mirror", + "note3": ["Random angle between -max and +max;", + "about half the skulls are mirrored."], + "title4": "Result", + "note4": ["Only the visible ink is written: nothing", + "hidden or masked, ready for laser engraving."], + }, + }, +} + +def _unit(angle): + """Vecteur unitaire, angle en degres, sens anti-horaire a l'ecran (y vers le bas).""" + a = math.radians(angle) + return math.cos(a), -math.sin(a) + + +out = [] +T = {} +FS = 1.0 + + +def fmt(v): + return "{:.2f}".format(v).rstrip("0").rstrip(".") + + +def pts(polyline): + return " ".join("{},{}".format(fmt(x), fmt(y)) for x, y in polyline) + + +def polyline(points, color, width, extra=""): + out.append(''.format(pts(points), color, fmt(width), extra)) + + +def motif(polylines, color, width): + for pl in polylines: + polyline(pl, color, width) + + +def text(x, y, s, size=17, color=INK, anchor="start", weight="normal", halo=True): + style = "{};font-size:{}px;font-weight:{};fill:{}".format( + FONT, fmt(size * FS), weight, color) + if halo: + style += ";paint-order:stroke;stroke:#ffffff;stroke-width:5px;stroke-linejoin:round" + out.append('{}'.format( + fmt(x), fmt(y), anchor, style, s)) + + +def note(x, y, lines): + """Legende de bas de panneau, derniere ligne sur la ligne de base `y`.""" + step = 22 * FS + for k, line in enumerate(lines): + text(x, y - (len(lines) - 1 - k) * step, line, size=16, halo=False) + + +def arrow_head(tip, direction, color, size=9): + ux, uy = direction + nx, ny = -uy, ux + base = (tip[0] - size * ux, tip[1] - size * uy) + out.append(''.format(pts([ + tip, (base[0] + 0.45 * size * nx, base[1] + 0.45 * size * ny), + (base[0] - 0.45 * size * nx, base[1] - 0.45 * size * ny)]), color)) + + +def dimension(p, q, offset, label, color=DIM, label_pos=0.5, label_shift=18, size=17): + """Cote entre p et q, decalee de `offset` perpendiculairement.""" + dx, dy = q[0] - p[0], q[1] - p[1] + length = math.hypot(dx, dy) + ux, uy = dx / length, dy / length + nx, ny = -uy, ux + a = (p[0] + offset * nx, p[1] + offset * ny) + b = (q[0] + offset * nx, q[1] + offset * ny) + sign = 1 if offset >= 0 else -1 + for base, end in ((p, a), (q, b)): + polyline([(base[0] + sign * 4 * nx, base[1] + sign * 4 * ny), + (end[0] + sign * 6 * nx, end[1] + sign * 6 * ny)], color, 1, + 'stroke-dasharray="3,3"') + polyline([a, b], color, 1.6) + arrow_head(a, (-ux, -uy), color) + arrow_head(b, (ux, uy), color) + lx = a[0] + label_pos * (b[0] - a[0]) + sign * label_shift * FS * nx + ly = a[1] + label_pos * (b[1] - a[1]) + sign * label_shift * FS * ny + 6 * FS + text(lx, ly, label, size=size, color=color, anchor="middle", weight="bold") + + +def arc(center, radius, a0, a1, color, label=None, label_radius=None, size=16): + """Arc de a0 a a1 degres (sens anti-horaire a l'ecran), fleche au bout.""" + steps = 40 + points = [] + for k in range(steps + 1): + ux, uy = _unit(a0 + (a1 - a0) * k / steps) + points.append((center[0] + radius * ux, center[1] + radius * uy)) + polyline(points[:-2], color, 1.6) + last, before = points[-1], points[-3] + d = math.hypot(last[0] - before[0], last[1] - before[1]) + arrow_head(last, ((last[0] - before[0]) / d, (last[1] - before[1]) / d), color, 8) + if label: + ux, uy = _unit((a0 + a1) / 2) + r = label_radius or radius + 24 + text(center[0] + r * ux, center[1] + r * uy + 6 * FS, label, size=size, + color=color, anchor="middle", weight="bold") + + +def circle_ring(cx, cy, r, n=180): + return [(cx + r * math.cos(2 * math.pi * k / n), cy + r * math.sin(2 * math.pi * k / n)) + for k in range(n)] + + +def panel_title(x, y, number, title): + text(x, y, "{} {}".format(number, title), size=22, weight="bold", halo=False) + + + +# -------------------------------------------------------------------------- +# Panneaux : un par parametre (ou groupe de parametres), numerotes 1 a 4. +# Dessiner avec les vraies fonctions de skull_fill_core, puis coter avec +# dimension() / arc() et legender avec note(). +# -------------------------------------------------------------------------- + +def skull(placement, color=EDGE, fill="#ffffff"): + """Crane du noyau, comme le dessine l'extension (silhouette, puis encre).""" + body, ink = skull_fill_core.skull_paths(placement) + if fill != "none": + out.append(''.format(body, fill)) + out.append(''.format(ink, color)) + + +def dot(x, y, color=DIM): + out.append(''.format(fmt(x), fmt(y), color)) + + +def panel_1(): + panel_title(30, 50, 1, T["title1"]) + small, big = 130, 330 + skull((190, 345, small, 0, False)) + skull((450, 330, big, 0, False)) + x = 190 - 0.42 * small + dimension((x, 345 - small / 2), (x, 345 + small / 2), 22, "min", label_shift=30) + x = 450 + 0.42 * big + dimension((x, 330 - big / 2), (x, 330 + big / 2), -22, "max", label_shift=30) + note(30, 610, T["note1"]) + + +def panel_2(): + panel_title(730, 50, 2, T["title2"]) + h, step = 120, 0.7 * 120 + rows = [] + for j, y in enumerate((330, 330 + 0.866 * step)): + for i in range(4): + rows.append((870 + (i + 0.5 * j) * step, y, h, 0, False)) + for placement in reversed(rows): + skull(placement) + for x, y, _h, _a, _m in rows: + dot(x, y) + dimension((rows[0][0], rows[0][1]), (rows[1][0], rows[1][1]), -95, + "70 %", label_shift=16) + note(730, 610, T["note2"]) + + +def panel_3(): + panel_title(30, 690, 3, T["title3"]) + c, h, angle = (220, 960), 280, 25 + skull((c[0], c[1], h, 0, False), color=GHOST, fill="none") + skull((c[0], c[1], h, angle, False)) + top = 175 + polyline([c, (c[0], c[1] - top)], DIM2, 1.2, 'stroke-dasharray="5,4"') + ux, uy = _unit(90 - angle) + polyline([c, (c[0] + top * ux, c[1] + top * uy)], DIM2, 1.2, 'stroke-dasharray="5,4"') + arc(c, 165, 90, 90 - angle, DIM2, T["tilt"], label_radius=190) + skull((470, 960, 140, 0, False)) + skull((620, 960, 140, 0, True)) + y = 1060 + polyline([(500, y), (590, y)], DIM, 1.6) + arrow_head((500, y), (-1, 0), DIM) + arrow_head((590, y), (1, 0), DIM) + text(545, y + 28, T["mirror"], size=17, color=DIM, anchor="middle", weight="bold") + note(30, 1250, T["note3"]) + + +def panel_4(): + panel_title(730, 690, 4, T["title4"]) + cx, cy, r = 1050, 950, 225 + ring = circle_ring(cx, cy, r) + region = skull_fill_core.Region([ring]) + placements = skull_fill_core.skull_placements([ring], 45, 140, seed=2) + # Exactement ce qu'ecrit l'extension : l'encre visible, les interstices, + # rien d'autre (pas de blanc, pas de masque). + gaps = skull_fill_core.visible_gaps(placements, region) + out.append(''.format( + skull_fill_core.rings_to_d(gaps), EDGE)) + for _placement, rings in skull_fill_core.visible_skulls(placements, region): + out.append(''.format( + skull_fill_core.rings_to_d(rings), EDGE)) + out.append(''.format(cx, cy, r + 6, DIM2)) + note(730, 1250, T["note4"]) + + +def export_png(svg_path, png_path, width): + exe = next((path for path in INKSCAPE if os.path.exists(path)), None) + if exe is None: + print("Inkscape introuvable : exporter {} a la main".format(svg_path)) + return + os.makedirs(os.path.dirname(png_path), exist_ok=True) + subprocess.run([exe, svg_path, "--export-type=png", + "--export-width={}".format(width), + "--export-filename={}".format(png_path)], + check=True, stderr=subprocess.DEVNULL) + print(png_path) + + +def build(language): + global FS + version = VERSIONS[language] + out.clear() + T.clear() + T.update(version["text"]) + FS = version["font_scale"] + + out.append(''.format(W, H)) + for x1, y1, x2, y2 in ((700, 20, 700, H - 20), (20, 640, W - 20, 640)): + out.append(''.format(x1, y1, x2, y2)) + panel_1() + panel_2() + panel_3() + panel_4() + svg = ('\n' + '\n{2}\n\n').format(W, H, "\n".join(out)) + with open(version["svg"], "w", encoding="utf-8", newline="\n") as handle: + handle.write(svg) + print(version["svg"]) + export_png(version["svg"], version["png"], version["png_width"]) + + +def main(argv): + languages = argv or sorted(VERSIONS) + for language in languages: + build(language) + + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/i18n.py b/i18n.py new file mode 100644 index 0000000..a800d7f --- /dev/null +++ b/i18n.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +# coding=utf-8 +""" +Chaine de traduction de l'extension, sans dependance a gettext. + + python i18n.py # extract + update + compile + python i18n.py extract # po/.pot depuis le .inx et les .py + python i18n.py update # reporte le modele dans po/.po + python i18n.py compile # po/.po -> locale//LC_MESSAGES/*.mo + +Le domaine est lu dans l'attribut translationdomain du .inx ; les sources sont +le .inx et tous les .py du dossier (hors i18n.py et tests). + +Les textes source (.inx et appels _() des .py) sont en anglais : c'est ce +qu'Inkscape affiche pour une langue sans catalogue. Le catalogue anglais est +rempli automatiquement avec les textes source ; seul fr.po se traduit a la main. + +Les chaines retenues dans le .inx suivent les regles d'Inkscape (inx.its) : +, attributs gui-text et gui-description, contenu de