Files

247 lines
12 KiB
Markdown

# Remplissage têtes de mort — extension Inkscape
<table>
<tr>
<td width="50%" valign="top">
<img src="docs/capture-desktop.png" alt="Cœur rempli de têtes de mort de tailles variées, inclinées et superposées, coupées au contour" width="420">
</td>
<td valign="top">
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é.
</td>
</tr>
</table>
## 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 (`<use>`), 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.