Initiale version

This commit is contained in:
Alex committed 2026-10-24 20:39:34 +02:00
commit 00e9ba3434
19 files changed
+2586

No files matched your search

+15
View File
@@ -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/
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 208 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 362 KiB

+387
View File
@@ -0,0 +1,387 @@
#!/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 dog_bandana_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 dog_bandana_core # noqa: E402
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": "Période et épaisseur du trait",
"period": "Période",
"width": "Épaisseur",
"note1": ["Période : d'axe en axe de deux lignes voisines.",
"Épaisseur : celle du trait, à bouts ronds ; la moitié",
"de la période donne autant de noir que de blanc."],
"title2": "Itérations",
"default": "{} (défaut)",
"iterations": "plus d'itérations",
"note2": ["Peu d'itérations : points et lignes courtes ; beaucoup :",
"longues lignes régulières. La graine aléatoire change",
"le dessin en gardant le même aspect."],
"title3": "Au bord de la forme",
"cut": "Couper les lignes",
"follow": "Longer le bord",
"note3": ["Couper : le motif est découpé comme un tissu.",
"Longer : les lignes s'arrêtent avant le bord et le suivent."],
"title4": "Marge",
"margin": "Marge",
"note4": ["Espace libre entre le bord de la forme et les traits",
"(bouts ronds compris). À 0, les traits touchent le bord."],
},
},
"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": "Period and line width",
"period": "Period",
"width": "Width",
"note1": ["Period: center to center of two neighbouring lines.",
"Width: round-capped stroke; half the period",
"gives as much black as white."],
"title2": "Iterations",
"default": "{} (default)",
"iterations": "more iterations",
"note2": ["Few iterations: dots and short lines; many:",
"long regular lines. The random seed changes",
"the drawing, not its look."],
"title3": "At the shape edge",
"cut": "Cut the lines",
"follow": "Follow the edge",
"note3": ["Cut: the pattern is cut like fabric.",
"Follow: lines stop before the edge, run along it."],
"title4": "Margin",
"margin": "Margin",
"note4": ["Free space between the shape edge and the",
"strokes (round tips included). 0: strokes touch it."],
},
},
}
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('<polyline points="{}" fill="none" stroke="{}" stroke-width="{}" '
'stroke-linejoin="miter" {}/>'.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('<text x="{}" y="{}" text-anchor="{}" style="{}">{}</text>'.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('<polygon points="{}" fill="{}"/>'.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.
# Motifs calcules par dog_bandana_core.turing_pattern, comme dans l'extension.
# --------------------------------------------------------------------------
def strokes(polylines, color, width):
"""Traits a bouts ronds, comme ceux produits par l'extension."""
for pl in polylines:
out.append('<polyline points="{}" fill="none" stroke="{}" stroke-width="{}" '
'stroke-linecap="round" stroke-linejoin="round"/>'.format(
pts(pl), color, fmt(width)))
def outline(rings, color=EDGE, width=2, extra=""):
d = " ".join("M " + " L ".join("{},{}".format(fmt(x), fmt(y)) for x, y in ring) + " Z"
for ring in rings)
out.append('<path d="{}" fill="none" stroke="{}" stroke-width="{}" {}/>'.format(
d, color, fmt(width), extra))
def rect_ring(x0, y0, x1, y1):
return [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
def crossings(polylines, x):
"""Intersections des polylignes avec la verticale x : (y, pente, numero)."""
found = []
for index, pl in enumerate(polylines):
for (ax, ay), (bx, by) in zip(pl, pl[1:]):
if (ax <= x) != (bx <= x):
t = (x - ax) / (bx - ax)
found.append((ay + t * (by - ay), abs((by - ay) / (bx - ax)), index))
return sorted(found)
def panel_1():
"""Periode et epaisseur : cotes sur deux lignes voisines bien paralleles."""
period, width = 64, 28
region = rect_ring(60, 90, 640, 530)
def near(cuts, index, y):
return any(i == index and abs(cy - y) < 6 for cy, _s, i in cuts)
# Cherche deux lignes voisines presque horizontales sur une bonne longueur
# (verticales x - 70, x, x + 70), espacees d'environ une periode : les
# cotes tiennent dans l'espace blanc entre elles.
best = None
for seed in range(1, 9):
lines = dog_bandana_core.turing_pattern([region], period, width, seed=seed,
steps=150)
for x in range(250, 480, 6):
cuts = crossings(lines, x)
left, right = crossings(lines, x - 70), crossings(lines, x + 70)
for (y1, s1, i1), (y2, s2, i2) in zip(cuts, cuts[1:]):
if not (170 < y1 < 400 and i1 != i2):
continue
if not all(near(c, i, y) for c in (left, right)
for i, y in ((i1, y1), (i2, y2))):
continue
score = abs(y2 - y1 - period) + 30 * (s1 + s2) + abs(x - 360) / 20
if best is None or score < best[0]:
best = (score, lines, x, y1, y2, i1, i2)
_score, lines, x, y1, y2, i1, i2 = best
panel_title(30, 50, 1, T["title1"])
strokes([pl for k, pl in enumerate(lines) if k not in (i1, i2)], GHOST, width)
strokes([lines[i1], lines[i2]], INK, width)
outline([region], EDGE, 2)
# Periode : d'axe en axe ; epaisseur : bord a bord d'une meme ligne.
for y in (y1, y2):
polyline([(x - 25, y), (x + 25, y)], DIM, 1.4, 'stroke-dasharray="4,3"')
dimension((x, y1), (x, y2), 0, "")
text(x + 12, (y1 + y2) / 2 + 6, T["period"], color=DIM, weight="bold")
# Epaisseur sur la ligne du bas, legende dessous (zone claire).
xw = x - 70
dimension((xw, y2 - width / 2), (xw, y2 + width / 2), 0, "", color=DIM2)
text(xw, y2 + width / 2 + 28, T["width"], color=DIM2, anchor="middle",
weight="bold")
note(30, 610, T["note1"])
def panel_2():
"""Iterations : meme graine, trois durees d'evolution."""
ox = 700
panel_title(ox + 30, 50, 2, T["title2"])
size, gap = 190, 25
for k, steps in enumerate((20, 60, 300)):
x0 = ox + 30 + k * (size + gap)
region = rect_ring(x0, 130, x0 + size, 130 + size)
lines = dog_bandana_core.turing_pattern([region], 20, 9, seed=5, steps=steps)
strokes(lines, INK, 9)
outline([region], EDGE, 2)
label = T["default"].format(steps) if steps == 60 else str(steps)
text(x0 + size / 2, 130 + size + 40, label, size=20, color=DIM,
anchor="middle", weight="bold")
arrow_y = 420
polyline([(ox + 60, arrow_y), (ox + 630, arrow_y)], DIM2, 1.6)
arrow_head((ox + 640, arrow_y), (1, 0), DIM2)
text(ox + 345, arrow_y + 30, T["iterations"], color=DIM2, anchor="middle",
weight="bold")
note(ox + 30, 610, T["note2"])
def panel_3():
"""Bord de la forme : motif coupe (tissu decoupe) ou qui longe le bord."""
oy = 640
panel_title(30, oy + 50, 3, T["title3"])
for k, edge in enumerate(("cut", "follow")):
cx, cy, r = 190 + k * 320, oy + 270, 140
ring = circle_ring(cx, cy, r)
lines = dog_bandana_core.turing_pattern([ring], 24, 11, seed=2, edge=edge)
strokes(lines, INK, 11)
outline([ring], EDGE, 2)
text(cx, cy + r + 40, T[edge], size=19, color=DIM, anchor="middle",
weight="bold")
note(30, oy + 610, T["note3"])
def panel_4():
"""Marge : espace libre entre le bord et les traits."""
ox, oy = 700, 640
panel_title(ox + 30, oy + 50, 4, T["title4"])
margin, period, width = 40, 30, 14
x0, y0, x1, y1 = ox + 70, oy + 90, ox + 630, oy + 470
lines = dog_bandana_core.turing_pattern([rect_ring(x0, y0, x1, y1)], period, width,
margin=margin, seed=6)
strokes(lines, INK, width)
outline([rect_ring(x0, y0, x1, y1)], EDGE, 2.5)
outline([rect_ring(x0 + margin, y0 + margin, x1 - margin, y1 - margin)], DIM2, 1.5,
'stroke-dasharray="6,4"')
dimension((x0, y1 + 22), (x0 + margin, y1 + 22), 0, "", color=DIM)
text(x0 + margin + 12, y1 + 29, T["margin"], color=DIM, weight="bold")
note(ox + 30, oy + 610, 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('<rect width="{}" height="{}" fill="#ffffff"/>'.format(W, H))
for x1, y1, x2, y2 in ((700, 20, 700, H - 20), (20, 640, W - 20, 640)):
out.append('<line x1="{}" y1="{}" x2="{}" y2="{}" stroke="#dee2e6" '
'stroke-width="1.5"/>'.format(x1, y1, x2, y2))
panel_1()
panel_2()
panel_3()
panel_4()
svg = ('<?xml version="1.0" encoding="UTF-8"?>\n'
'<svg xmlns="http://www.w3.org/2000/svg" width="{0}" height="{1}" '
'viewBox="0 0 {0} {1}">\n{2}\n</svg>\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:])
+203
View File
@@ -0,0 +1,203 @@
# Dog Bandana — extension Inkscape
<table>
<tr>
<td width="50%" valign="top">
<img src="docs/apercu.png" alt="Formes de test (rectangle, cercle, forme libre, rectangle troué, ellipse) remplies d'un labyrinthe de Turing : lignes noires sinueuses à bouts ronds" width="420">
</td>
<td valign="top">
Extension Inkscape 1.x qui remplit les formes sélectionnées d'un **labyrinthe de
Turing**, le motif « vermicelles » du dossier `docs/` : des lignes sinueuses
d'épaisseur constante, qui bifurquent, se referment parfois en boucle et se
terminent en bouts ronds.
Le motif est calculé (équation de Swift-Hohenberg, régime labyrinthe) sur une
grille qui couvre la forme, puis réduit à la **ligne centrale** de chaque bande :
un seul trait à bouts ronds par vermicelle, prêt pour la gravure laser en mode
ligne, dans un ordre qui limite les déplacements à vide de la tête.
</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 dans des
groupes (transformations comprises) ; les trous sont respectés (règle
pair-impair). Les autres éléments (texte, images…) sont ignorés.
- Lignes centrales seulement : un `<path>` par forme, `stroke-linecap:round`,
épaisseur du trait = largeur des vermicelles ; le trait entier (bouts ronds
compris) reste dans la forme, à la marge près.
- Deux comportements au bord : lignes **coupées** comme un tissu découpé (par
défaut), ou lignes qui **longent** le bord.
- Aspect réglable : peu d'itérations donnent points et lignes courtes (proche de
l'image de référence), beaucoup de longues lignes régulières ; la graine
aléatoire change le dessin en gardant l'aspect. Même graine, même résultat.
- Ordre de gravure optimisé pour la découpeuse laser : les traits qui se
touchent sont enchaînés, puis ordonnés au plus proche voisin. Sur un rectangle
de 150 × 100 mm (période 4 mm), 230 traits deviennent 131 et les trajets à vide
passent de 9 451 mm à 1 090 mm (÷ 8,7) ; sur 300 × 200 mm, de 71 690 mm à
4 179 mm (÷ 17). Désactiver la réoptimisation du logiciel du laser (LightBurn…)
pour garder cet ordre.
- Temps de calcul : environ 1 s pour 150 × 100 mm, 4 s pour 300 × 200 mm
(période 4 mm). Au-delà de 3 millions de pixels de calcul, l'extension demande
d'augmenter la période ou de découper la forme.
- 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` et `numpy`, fournis avec
Inkscape.
### Windows (script)
Inkscape fermé, depuis le dossier du projet :
```powershell
.\deploy.ps1 # installe dans %APPDATA%\inkscape\extensions\dogBandana
.\deploy.ps1 -Uninstall # désinstalle
.\deploy.ps1 -Force # installe même si Inkscape est ouvert (redémarrage requis)
```
### Manuelle
Copier dans un sous-dossier du répertoire des extensions utilisateur :
- `dog_bandana.inx`, `dog_bandana.py`, `dog_bandana_core.py` ;
- `images/parameters_en.png` ;
- `locale/` (traductions compilées).
| Système | Dossier 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 fermées (ou des groupes).
2. Menu **Extensions › AlexDesign › Remplissage par motif Dog Bandana** (*Dog Bandana Pattern Fill* en anglais).
3. Régler période, épaisseur, marge, itérations et bord dans l'onglet **Motif**,
couleur et conservation de la forme dans **Style** ; l'onglet **Aide** reprend
le schéma ci-dessous.
4. Appliquer : le motif est placé dans un groupe « Motif Dog Bandana » juste
au-dessus de chaque forme.
**Conseils**
| Symptôme | Réglage |
| ----------------------------------------- | ----------------------------------------------------------- |
| Lignes qui se touchent | Réduire l'épaisseur du trait (≈ moitié de la période) |
| Trop de points et de petits bouts | Augmenter les itérations (100 à 300) |
| Motif trop régulier, peu « organique » | Réduire les itérations (20 à 40) |
| Le dessin ne plaît pas | Changer la graine aléatoire |
| Anneaux concentriques le long du bord | Choisir « Couper les lignes » au bord de la forme |
| « Forme trop étroite pour le motif » | Réduire épaisseur, période ou marge |
| « Forme trop grande pour cette période » | Augmenter la période ou découper la forme |
## Paramètres
![Schéma des paramètres](docs/parametres.png)
| Paramètre | Défaut | Rôle |
| --------------------------------------------------- | ----------------------- | -------------------------------------------------------------------- |
| Période (écart entre les lignes, d'axe en axe) | 4 | Distance entre les axes de deux lignes voisines |
| Épaisseur du trait | 2 | Largeur des vermicelles ; doit rester inférieure à la période |
| Marge au bord de la forme | 0 | Espace libre entre le bord et les traits (bouts ronds compris) |
| Unité | mm | Unité des trois longueurs ci-dessus (mm, cm, px, pt, in) |
| Itérations | 60 | Durée d'évolution du motif : peu = points et lignes courtes, beaucoup = longues lignes |
| Graine aléatoire | 1 | Change le dessin, pas son aspect |
| Au bord de la forme | Couper les lignes | Couper comme un tissu, ou longer le bord |
| Couleur du trait | noir | Couleur et opacité des traits |
| Conserver la forme d'origine | oui | Sinon la forme source est supprimée |
## Structure du projet
```text
dog_bandana.inx Boîte de dialogue (textes source en anglais)
dog_bandana.py Couche inkex : sélection, unités, contours, écriture SVG
dog_bandana_core.py Calcul du motif et ordre de gravure, sans inkex (numpy)
i18n.py Extraction / mise à jour / compilation des traductions
po/ Catalogues : dogbandana.pot, en.po, fr.po
locale/ Traductions compilées (.mo), déployées
images/parameters_en.png Schéma de l'onglet « Help » (déployé)
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/apercu.png Aperçu du résultat (bandeau du README)
docs/*.jpg Image de référence du motif
tests/data/ Formes d'exemple (dont une page à l'échelle non standard)
test_dog_bandana.py Tests pytest
deploy.ps1 Déploiement / désinstallation Windows
```
API du module `dog_bandana_core` :
| Fonction | Rôle |
| -------- | ---- |
| `turing_pattern(rings, period, line_width, margin=0, seed=1, edge="cut", pixels_per_period=8, steps=60)` | Lignes centrales du labyrinthe qui remplit les anneaux (`edge` : `"cut"` ou `"follow"`) |
| `grid_pixels(rings, period)` | Taille de la grille de calcul (garde-fou de durée) |
| `rasterize(rings, x0, y0, step, nx, ny)` | Masque pair-impair des pixels intérieurs |
| `erode(mask, radius)` | Érosion par un disque (FFT) : marge et demi-épaisseur |
| `swift_hohenberg(shape, pixels_per_period, seed, steps, outside=None)` | Champ du régime labyrinthe (schéma spectral semi-implicite) |
| `skeletonize(binary)` | Squelette d'un pixel (Zhang-Suen) |
| `trace_skeleton(skeleton, min_spur=0)` | Polylignes du squelette, ergots supprimés |
| `smooth_polyline(points, passes)` / `simplify_polyline(points, tolerance)` | Lissage et simplification (Ramer-Douglas-Peucker) |
| `laser_order(polylines, start)` | Enchaîne puis ordonne les traits pour le laser |
| `chain_polylines(polylines)` / `order_polylines(polylines, start)` | Les deux étapes de `laser_order` |
| `travel_length(polylines, start)` | Longueur des déplacements à vide |
| `parse_color(value)` | Couleur Inkscape (entier RGBA) → `#rrggbb`, opacité |
| `polylines_to_d(polylines, precision)` | Données `d` d'un chemin SVG |
## Développement
```powershell
python -m venv .venv
.venv\Scripts\activate
pip install pytest numpy lxml tinycss2 cssselect
python -m pytest -q # 30 réussis, 7 ignorés (sans inkex)
$env:PYTHONPATH = 'C:\Program Files\Inkscape\share\inkscape\extensions'
python -m pytest -q # 37 réussis
```
Les tests couvrent les étapes du calcul (masque pair-impair, érosion, squelette,
suivi des branches et ergots, lissage, simplification), le motif lui-même (traits
dans la forme à la marge près dans les deux modes de bord, densité conforme à la
période, trous respectés, reproductibilité par graine, effet des itérations, cas
vides), l'ordre de gravure, l'extension de bout en bout (groupes, messages
d'erreur, page à l'échelle non standard), les traductions et la cohérence `.inx`
↔ arguments.
### Traductions
```bash
python i18n.py # extract + update + compile ; liste les msgstr manquants
```
Après modification d'un texte du `.inx` ou d'un `_("...")` : lancer
`python i18n.py`, compléter les `msgstr` vides de `po/fr.po`, relancer. `en.po` se
remplit seul ; ne jamais éditer les `.mo`. Pour une nouvelle langue : l'ajouter à
`LANGUAGES` dans `i18n.py`.
### Schéma des paramètres
```bash
python docs/schema_parametres.py # fr → docs/parametres.png (1400 px)
# en → images/parameters_en.png (900 px)
```
Les motifs du schéma sont calculés par `dog_bandana_core`, comme dans
l'extension. L'export PNG passe par `C:\Program Files\Inkscape\bin\inkscape.com`.
+107
View File
@@ -0,0 +1,107 @@
<#
.SYNOPSIS
Déploie l'extension « Dog Bandana » dans Inkscape.
.DESCRIPTION
Copie dog_bandana.inx, dog_bandana.py, dog_bandana_core.py, le schéma de l'onglet
« Help » (images\parameters_en.png) et les traductions
compilées (locale\<langue>\LC_MESSAGES\dogbandana.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 : dogBandana
.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 = 'dogBandana',
[switch] $Uninstall,
[switch] $Force
)
$ErrorActionPreference = 'Stop'
$files = @('dog_bandana.inx', 'dog_bandana.py', 'dog_bandana_core.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 > Dog Bandana..."
+79
View File
@@ -0,0 +1,79 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Textes source en anglais, traduits par le catalogue « dogbandana »
(locale/<langue>/LC_MESSAGES/dogbandana.mo). Après toute modification
d'un texte : python i18n.py, puis compléter po/fr.po et relancer.
-->
<inkscape-extension translationdomain="dogbandana"
xmlns="http://www.inkscape.org/namespace/inkscape/extension">
<name>Dog Bandana Pattern Fill</name>
<id>fr.alexp.dogbandana</id>
<param name="tab" type="notebook">
<page name="pattern" gui-text="Pattern">
<param name="period" type="float" precision="2" min="0.2" max="1000"
gui-text="Period (line spacing, center to center):">4.0</param>
<param name="line_width" type="float" precision="2" min="0.05" max="1000"
gui-text="Line width:">2.0</param>
<param name="margin" type="float" precision="2" min="0" max="1000"
gui-text="Margin from the shape edge:">0.0</param>
<param name="unit" type="optiongroup" appearance="combo" gui-text="Unit:">
<!-- Les unités ne se traduisent pas -->
<option translatable="no" value="mm">mm</option>
<option translatable="no" value="cm">cm</option>
<option translatable="no" value="px">px</option>
<option translatable="no" value="pt">pt</option>
<option translatable="no" value="in">in</option>
</param>
<separator/>
<param name="iterations" type="int" min="10" max="500"
gui-text="Iterations (more = longer, smoother lines):"
gui-description="Few iterations leave many dots and short lines; many iterations give long, regular lines.">60</param>
<param name="seed" type="int" min="0" max="999999"
gui-text="Random seed (another number, another maze):">1</param>
<param name="edge" type="optiongroup" appearance="combo" gui-text="At the shape edge:">
<option value="cut">Cut the lines (like cut fabric)</option>
<option value="follow">Lines follow the edge</option>
</param>
</page>
<page name="style" gui-text="Style">
<param name="stroke_color" type="color" appearance="colorbutton"
gui-text="Line color:">255</param>
<param name="keep_original" type="bool"
gui-text="Keep the original shape">true</param>
</page>
<page name="help" gui-text="Help">
<!-- Schéma généré par docs/schema_parametres.py, en anglais :
Inkscape ne traduit pas le chemin d'une image. Affiché aux
3/4 du PNG (900 px) pour limiter la hauteur de l'onglet. -->
<image width="675" height="617">images/parameters_en.png</image>
<separator/>
<!-- Un paragraphe par ligne : Inkscape le replie à la largeur de
l'onglet ; des retours à la ligne forcés le laisseraient étroit. -->
<label xml:space="preserve">Select one or more closed shapes (or groups), then run the extension. Each shape is filled with a Turing maze: winding lines of constant width that branch and end in round tips.
Each line is drawn once, along its center, with a round-capped stroke of the chosen width: ready for line engraving on a laser cutter. The lines are chained and ordered to limit idle travel of the laser head.
Period: distance between the centers of two neighbouring lines. Line width: stroke thickness; keep it below the period (about half gives as much black as white). Margin: free space between the shape edge and the strokes.
Iterations: how long the pattern evolves. Few iterations leave dots and short lines, many give long regular lines. The seed changes the drawing while keeping the same look.
At the shape edge: cut the lines like a piece of fabric, or let them stop before the edge and run along it.
The result is placed in a group just above each shape. Large shapes with a small period take a few seconds.</label>
</page>
</param>
<effect>
<object-type>all</object-type>
<effects-menu>
<submenu name="AlexDesign"/>
</effects-menu>
</effect>
<script>
<command location="inx" interpreter="python">dog_bandana.py</command>
</script>
</inkscape-extension>
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env python3
# coding=utf-8
"""
Extension Inkscape : remplit les formes selectionnees d'un labyrinthe de
Turing (motif « Dog Bandana »), trace en lignes centrales a bouts ronds.
Le motif est calcule par l'equation de Swift-Hohenberg sur une grille qui
couvre la forme, puis reduit a la ligne centrale de chaque bande : un trait
par « vermicelle », pret pour la gravure laser en mode ligne.
La logique vit dans `dog_bandana_core`, sans dependance a inkex.
"""
import os
import sys
import inkex
from inkex.bezier import cspsubdiv
from inkex.localization import localize
from inkex.units import convert_unit
# L'extension vit dans son propre sous-dossier des extensions Inkscape, qui
# n'est pas forcement dans sys.path : on l'y ajoute pour trouver dog_bandana_core.
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from dog_bandana_core import (MAX_PIXELS, grid_pixels, laser_order, # noqa: E402
parse_color, polylines_to_d, turing_pattern)
def use_system_language():
"""Renseigne LANGUAGE avec la langue du systeme si rien ne la fixe.
Sous Windows, Inkscape regle sur « langue du systeme » ne transmet aucune
variable de langue au script : gettext retomberait sur l'anglais alors que
la boite de dialogue, traduite par Inkscape lui-meme, est dans la langue
de l'utilisateur.
"""
if any(os.environ.get(name) for name in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG")):
return
try:
import ctypes
import locale
language = locale.windows_locale.get(
ctypes.windll.kernel32.GetUserDefaultUILanguage())
except Exception: # pylint: disable=broad-except
return # hors Windows : LANG est toujours defini
if language:
os.environ["LANGUAGE"] = language
# Installe _() dans les builtins : catalogue « dogbandana » de la langue
# de l'interface (Inkscape transmet domaine et dossier par l'environnement),
# textes anglais d'origine sinon.
use_system_language()
localize()
# Elements qui delimitent une surface a remplir.
SHAPES = (inkex.PathElement, inkex.Rectangle, inkex.Circle, inkex.Ellipse,
inkex.Polygon)
def uu_per_mm(svg):
"""Unites utilisateur par millimetre, comme Inkscape les affiche.
svg.unittouu() devine l'unite du document par arrondi a l'unite connue la
plus proche : il se trompe des que l'echelle n'est pas standard (page
redimensionnee). On prend le rapport reel page / viewBox ; Inkscape
applique une echelle uniforme (preserveAspectRatio « meet »), soit la
plus petite des deux.
"""
try:
vb_w, vb_h = svg.viewbox_width, svg.viewbox_height
page_w = svg.to_dimensional(svg.viewport_width, "mm")
page_h = svg.to_dimensional(svg.viewport_height, "mm")
except AttributeError: # inkex anterieur a 1.2
return svg.unittouu("1mm")
if not (vb_w and vb_h and page_w and page_h):
return svg.unittouu("1mm")
return 1 / min(page_w / vb_w, page_h / vb_h)
def length_to_uu(svg, value, unit="mm"):
"""Longueur reelle (valeur + unite) -> unites utilisateur du document."""
return convert_unit("{}{}".format(value, unit), "mm") * uu_per_mm(svg)
def element_rings(elem, flatness):
"""Contour de l'element en coordonnees absolues : liste d'anneaux.
Les courbes sont aplaties en polylignes (ecart maximal `flatness`).
"""
path = elem.path.transform(elem.composed_transform())
csp = path.to_superpath()
cspsubdiv(csp, flatness)
rings = []
for sub in csp:
ring = [(node[1][0], node[1][1]) for node in sub]
if len(ring) > 1 and ring[0] == ring[-1]:
ring.pop()
if len(ring) >= 3:
rings.append(ring)
return rings
class DogBandana(inkex.EffectExtension):
"""Remplit chaque forme selectionnee d'un labyrinthe de Turing."""
def add_arguments(self, pars):
# Un argument par <param> du .inx, memes noms et memes valeurs par defaut.
pars.add_argument("--tab", default="pattern")
pars.add_argument("--period", type=float, default=4.0)
pars.add_argument("--line_width", type=float, default=2.0)
pars.add_argument("--margin", type=float, default=0.0)
pars.add_argument("--unit", default="mm")
pars.add_argument("--iterations", type=int, default=60)
pars.add_argument("--seed", type=int, default=1)
pars.add_argument("--edge", default="cut")
pars.add_argument("--stroke_color", default="255")
pars.add_argument("--keep_original", type=inkex.Boolean, default=True)
def effect(self):
opt = self.options
shapes = []
for elem in self.svg.selection.values():
if isinstance(elem, SHAPES):
shapes.append(elem)
elif isinstance(elem, inkex.Group):
shapes.extend(e for e in elem.descendants() if isinstance(e, SHAPES))
if not shapes:
inkex.errormsg(_("Select at least one closed shape (path, rectangle, "
"circle, ellipse, polygon) or a group containing some."))
return
period = length_to_uu(self.svg, opt.period, opt.unit)
width = length_to_uu(self.svg, opt.line_width, opt.unit)
margin = length_to_uu(self.svg, opt.margin, opt.unit)
if period <= 0 or width <= 0:
inkex.errormsg(_("The period and the line width must be strictly positive."))
return
if width >= period:
inkex.errormsg(_("The line width must be smaller than the period, "
"otherwise neighbouring lines merge. Reduce the line "
"width or increase the period."))
return
color, opacity = parse_color(opt.stroke_color, ("#000000", 1.0))
style = inkex.Style({
"fill": "none",
"stroke": color,
"stroke-opacity": str(opacity),
"stroke-width": str(width),
"stroke-linecap": "round",
"stroke-linejoin": "round",
})
# Position de la tete du laser : chaque trace demarre la ou le
# precedent s'est arrete (voir path_element).
self.head = (0.0, 0.0)
empty = 0
for elem in shapes:
rings = element_rings(elem, period / 50)
if grid_pixels(rings, period) > MAX_PIXELS:
inkex.errormsg(_("The shape is too large for this period: the "
"computation would take too long. Increase the "
"period or split the shape."))
return
if not self.process(elem, rings, period, width, margin, style):
empty += 1
if empty:
inkex.errormsg(_("{} shape(s) too narrow for the pattern: reduce the "
"line width, the period or the margin.").format(empty))
def path_element(self, polylines, style):
"""Chemin SVG des traits, dans l'ordre de gravure optimise.
Les traits qui se touchent sont enchaines, puis ordonnes au plus pres
de la position de la tete : moins de deplacements a vide du laser.
Tout trait genere passe par ici.
"""
polylines = laser_order(polylines, self.head)
if polylines:
self.head = polylines[-1][-1]
node = inkex.PathElement()
node.path = polylines_to_d(polylines, precision=3)
node.style = style
return node
def process(self, elem, rings, period, width, margin, style):
"""Remplit un element ; renvoie False si la forme est trop etroite."""
opt = self.options
polylines = turing_pattern(rings, period, width, margin, seed=opt.seed,
edge=opt.edge, steps=opt.iterations)
if not polylines:
return False
parent = elem.getparent()
group = inkex.Group()
group.label = _("Dog Bandana pattern")
if parent is not None:
# Resultat calcule en coordonnees absolues du document : on
# neutralise la transformation heritee du parent d'accueil.
parent_transform = parent.composed_transform()
if parent_transform != inkex.Transform():
group.transform = -parent_transform
parent.insert(parent.index(elem) + 1, group)
else:
self.svg.add(group)
group.add(self.path_element(polylines, style))
if not opt.keep_original:
elem.delete()
return True
if __name__ == "__main__":
DogBandana().run()
+537
View File
@@ -0,0 +1,537 @@
# coding=utf-8
"""
Noyau de calcul de l'extension « Dog Bandana », sans dependance a inkex.
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
des parametres).
Conventions :
- un contour (`rings`) est une liste d'anneaux, chaque anneau etant une liste
de points (x, y) fermee implicitement ; les trous suivent la regle pair-impair ;
- une polyligne est une liste de points (x, y) ;
- l'axe y est oriente vers le bas (repere SVG).
Le motif est un labyrinthe de Turing (bandes de largeur constante qui
serpentent, bifurquent et se terminent en bouts ronds) : `turing_pattern`
renvoie la ligne centrale de chaque bande, a tracer avec un trait a bouts
ronds. Seule dependance : numpy, fourni avec Inkscape (inkex en depend).
Les traits produits passent par `laser_order` avant d'etre ecrits : ils sont
enchaines et ordonnes pour limiter les deplacements a vide de la tete du laser.
"""
import math
import numpy as np
def parse_color(value, default=("#b3b3b3", 1.0)):
"""Couleur Inkscape (entier RGBA decimal ou 0x..., ou #rrggbb[aa]).
Renvoie (couleur CSS #rrggbb, opacite entre 0 et 1). Le parametre
« color » d'Inkscape arrive sous forme d'entier RGBA ; on le decode
nous-memes pour ne pas dependre de l'API couleur d'inkex, qui a change
entre les versions 1.x.
"""
text = str(value).strip()
try:
if text.startswith("#"):
digits = text[1:]
if len(digits) == 3:
digits = "".join(c * 2 for c in digits)
if len(digits) == 6:
digits += "ff"
if len(digits) != 8:
return default
number = int(digits, 16)
else:
number = int(text, 0)
except ValueError:
return default
number &= 0xFFFFFFFF
red, green, blue = (number >> 24) & 255, (number >> 16) & 255, (number >> 8) & 255
alpha = (number & 255) / 255.0
return "#{:02x}{:02x}{:02x}".format(red, green, blue), round(alpha, 4)
def polylines_to_d(polylines, precision=4):
"""Donnees `d` d'un chemin SVG : une polyligne par sous-chemin."""
fmt = "{:.%df},{:.%df}" % (precision, precision)
parts = []
for polyline in polylines:
if len(polyline) < 2:
continue
parts.append("M " + fmt.format(*polyline[0]))
parts.extend("L " + fmt.format(*point) for point in polyline[1:])
return " ".join(parts)
# --------------------------------------------------------------------------
# Ordre de gravure (decoupeuse laser)
# --------------------------------------------------------------------------
def _key(point):
"""Cle d'un point : deux extremites a 1e-6 pres sont le meme noeud."""
return round(point[0], 6), round(point[1], 6)
def _is_closed(line):
return len(line) > 2 and _key(line[0]) == _key(line[-1])
def chain_polylines(polylines):
"""Met bout a bout les polylignes qui se touchent par leurs extremites.
Le laser parcourt alors chaque resultat d'un trait, sans lever la tete.
Les polylignes sont les aretes d'un graphe dont les noeuds sont leurs
extremites ; on part d'abord des noeuds de degre impair (bouts de
branche) : un parcours qui y commence ne peut s'arreter que sur un autre
noeud impair, ce qui limite le nombre de traits, donc de sauts a vide.
Une polyligne deja fermee (boucle) est gardee telle quelle.
"""
out = []
points = {}
adjacency = {} # noeud -> [(numero de polyligne, voisin)]
lines = [list(line) for line in polylines if len(line) >= 2]
for index, line in enumerate(lines):
a, b = _key(line[0]), _key(line[-1])
if a == b:
out.append(line)
continue
points.setdefault(a, line[0])
points.setdefault(b, line[-1])
adjacency.setdefault(a, []).append((index, b))
adjacency.setdefault(b, []).append((index, a))
used = [False] * len(lines)
def free_edges(node):
edges = adjacency[node]
edges[:] = [edge for edge in edges if not used[edge[0]]]
return edges
def walk(node):
chain = [points[node]]
while True:
edges = free_edges(node)
if not edges:
return chain
index, following = edges.pop()
used[index] = True
line = lines[index]
if _key(line[0]) != node:
line = line[::-1]
chain.extend(line[1:])
node = following
for node in adjacency:
if len(free_edges(node)) % 2:
out.append(walk(node))
for node in adjacency: # reste : circuits fermes
while free_edges(node):
out.append(walk(node))
return out
def order_polylines(polylines, start=(0.0, 0.0)):
"""Ordonne les polylignes pour limiter les deplacements a vide du laser.
Plus proche voisin : depuis la fin de la polyligne precedente (ou
`start`), on enchaine sur l'entree libre la plus proche. Une polyligne
ouverte peut etre parcourue dans les deux sens ; une boucle fermee peut
commencer a n'importe lequel de ses sommets. Les entrees sont rangees
dans une grille pour ne pas tout comparer a chaque pas.
"""
polylines = [list(line) for line in polylines if len(line) >= 2]
if not polylines:
return []
entries = [] # (numero de polyligne, sommet d'entree)
for index, line in enumerate(polylines):
if _is_closed(line):
entries.extend((index, k) for k in range(len(line) - 1))
else:
entries.extend(((index, 0), (index, len(line) - 1)))
xs = [polylines[i][k][0] for i, k in entries]
ys = [polylines[i][k][1] for i, k in entries]
x0, y0 = min(xs), min(ys)
width, height = max(xs) - x0, max(ys) - y0
cell = math.sqrt(width * height / len(entries)) or max(width, height) / len(entries) or 1.0
nx, ny = int(width / cell), int(height / cell)
grid = {}
for entry, x, y in zip(entries, xs, ys):
grid.setdefault((int((x - x0) / cell), int((y - y0) / cell)), []).append(entry)
done = [False] * len(polylines)
def ring(cx, cy, r):
"""Cellules de la grille a distance r (en cellules) de (cx, cy)."""
if r == 0:
yield cx, cy
return
for gx in range(max(cx - r, 0), min(cx + r, nx) + 1):
if 0 <= cy - r <= ny:
yield gx, cy - r
if 0 <= cy + r <= ny:
yield gx, cy + r
for gy in range(max(cy - r + 1, 0), min(cy + r - 1, ny) + 1):
if 0 <= cx - r <= nx:
yield cx - r, gy
if 0 <= cx + r <= nx:
yield cx + r, gy
def nearest(x, y):
cx = int(math.floor((x - x0) / cell))
cy = int(math.floor((y - y0) / cell))
r = max(0, -cx, cx - nx, -cy, cy - ny) # premier anneau dans la grille
r_max = max(cx, nx - cx, cy, ny - cy, r)
best, best_d = None, float("inf")
while r <= r_max and (r - 1) * cell < best_d:
for key in ring(cx, cy, r):
bucket = grid.get(key)
if not bucket:
continue
bucket[:] = [e for e in bucket if not done[e[0]]]
for index, k in bucket:
px, py = polylines[index][k]
d = math.hypot(px - x, py - y)
if d < best_d:
best, best_d = (index, k), d
r += 1
return best
ordered = []
position = start
for _ in range(len(polylines)):
index, k = nearest(*position)
done[index] = True
line = polylines[index]
if k == 0:
pass
elif not _is_closed(line):
line = line[::-1]
else: # boucle : rotation
line = line[k:-1] + line[:k] + [line[k]]
ordered.append(line)
position = line[-1]
return ordered
def laser_order(polylines, start=(0.0, 0.0)):
"""Enchaine puis ordonne les traits : a appliquer avant polylines_to_d.
`start` : position de la tete (fin du trace precedent, ou origine).
La position finale est le dernier point de la derniere polyligne.
"""
return order_polylines(chain_polylines(polylines), start)
def travel_length(polylines, start=(0.0, 0.0)):
"""Longueur totale des deplacements a vide (tete levee) entre polylignes."""
total = 0.0
position = start
for line in polylines:
total += math.hypot(line[0][0] - position[0], line[0][1] - position[1])
position = line[-1]
return total
# --------------------------------------------------------------------------
# Motif de Turing (labyrinthe)
# --------------------------------------------------------------------------
#
# Regime « labyrinthe » de l'equation de Swift-Hohenberg :
# du/dt = r.u - (1 + laplacien)^2 u - u^3
# integree sur une grille de pixels couvrant la forme. Partant d'un bruit
# aleatoire, le champ u s'organise en bandes de periode 2.pi (unites reduites).
# Les bandes positives sont amincies en squelette d'un pixel, suivi en
# polylignes, lisse puis simplifie.
PIXELS_PER_PERIOD = 8 # resolution du calcul
STEPS = 60 # pas d'integration : plus, bandes plus longues
SMOOTHING = 4 # passes de lissage des lignes centrales
EDGE_MODES = ("cut", "follow")
MAX_PIXELS = 3000000 # au-dela, calcul trop long dans Inkscape
def rasterize(rings, x0, y0, step, nx, ny):
"""Masque booleen (ny, nx) des centres de pixels interieurs (pair-impair).
Pixel (i, j) : centre en (x0 + (j + 0.5) * step, y0 + (i + 0.5) * step).
Balayage par lignes : pour chaque ligne, abscisses des intersections avec
les aretes, triees ; un pixel est dedans s'il a un nombre impair
d'intersections a sa gauche.
"""
mask = np.zeros((ny, nx), dtype=bool)
edges = [(ring[k], ring[(k + 1) % len(ring)]) for ring in rings
for k in range(len(ring))]
if not edges:
return mask
ax, ay, bx, by = (np.array(v, dtype=float) for v in zip(
*[(a[0], a[1], b[0], b[1]) for a, b in edges]))
columns = x0 + (np.arange(nx) + 0.5) * step
for i in range(ny):
y = y0 + (i + 0.5) * step
# Arete demi-ouverte : un sommet partage n'est compte qu'une fois.
hit = (ay <= y) != (by <= y)
if not hit.any():
continue
t = (y - ay[hit]) / (by[hit] - ay[hit])
xs = np.sort(ax[hit] + t * (bx[hit] - ax[hit]))
mask[i] = np.searchsorted(xs, columns) % 2 == 1
return mask
def erode(mask, radius):
"""Erosion du masque par un disque de `radius` pixels.
Convolution par FFT : un pixel reste s'il n'y a aucun pixel exterieur
dans le disque qui l'entoure. La convolution est periodique : la grille
doit garder une bordure exterieure d'au moins `radius` pixels.
"""
if radius <= 0:
return mask.copy()
ny, nx = mask.shape
iy = np.minimum(np.arange(ny), ny - np.arange(ny))[:, None]
ix = np.minimum(np.arange(nx), nx - np.arange(nx))[None, :]
disk = (ix ** 2 + iy ** 2 <= radius ** 2).astype(float)
hits = np.fft.irfft2(np.fft.rfft2((~mask).astype(float)) * np.fft.rfft2(disk),
s=mask.shape)
return mask & (hits < 0.5)
def swift_hohenberg(shape, pixels_per_period=PIXELS_PER_PERIOD, seed=1,
steps=STEPS, outside=None, r=0.35, dt=0.5):
"""Champ u (ny, nx) du regime labyrinthe.
Schema spectral semi-implicite : partie lineaire implicite (stable quel
que soit le pas de temps), terme cubique explicite ; bords periodiques.
`outside` (masque booleen, optionnel) : pixels ou u est force a -1 a
chaque pas ; les bandes s'arretent alors avant ce masque et longent son
bord, au lieu d'etre coupees net.
"""
ny, nx = shape
rng = np.random.default_rng(seed)
u = 0.1 * rng.standard_normal((ny, nx))
spacing = 2 * math.pi / pixels_per_period # pixel en unites reduites
kx = 2 * math.pi * np.fft.rfftfreq(nx, d=spacing)
ky = 2 * math.pi * np.fft.fftfreq(ny, d=spacing)
k2 = ky[:, None] ** 2 + kx[None, :] ** 2
denominator = 1 - dt * (r - (1 - k2) ** 2)
for _ in range(steps):
if outside is not None:
u[outside] = -1.0
u_hat = np.fft.rfft2(u - dt * u ** 3)
u = np.fft.irfft2(u_hat / denominator, s=(ny, nx))
if outside is not None:
u[outside] = -1.0
return u
def skeletonize(binary):
"""Squelette d'un pixel d'epaisseur (Zhang-Suen), vectorise avec numpy."""
img = np.pad(binary.astype(np.uint8), 1)
while True:
changed = False
for first in (True, False):
p2, p3, p4 = img[:-2, 1:-1], img[:-2, 2:], img[1:-1, 2:]
p5, p6, p7 = img[2:, 2:], img[2:, 1:-1], img[2:, :-2]
p8, p9 = img[1:-1, :-2], img[:-2, :-2]
around = [p2, p3, p4, p5, p6, p7, p8, p9, p2]
neighbours = sum(around[:8])
transitions = sum(((a == 0) & (b == 1)).astype(np.uint8)
for a, b in zip(around, around[1:]))
if first:
c1, c2 = p2 * p4 * p6, p4 * p6 * p8
else:
c1, c2 = p2 * p4 * p8, p2 * p6 * p8
remove = ((img[1:-1, 1:-1] == 1) & (neighbours >= 2) & (neighbours <= 6)
& (transitions == 1) & (c1 == 0) & (c2 == 0))
if remove.any():
img[1:-1, 1:-1][remove] = 0
changed = True
if not changed:
return img[1:-1, 1:-1].astype(bool)
_NEIGHBOURS = ((-1, 0), (0, 1), (1, 0), (0, -1), (-1, -1), (-1, 1), (1, 1), (1, -1))
def _skeleton_graph(skeleton):
"""Voisins de chaque pixel du squelette.
Liaisons 8-connexes, sauf une diagonale doublee par deux liaisons droites
(coin en « L ») : elle creerait de faux carrefours.
"""
pixels = set(zip(*(index.tolist() for index in np.nonzero(skeleton))))
graph = {}
for (i, j) in pixels:
links = []
for di, dj in _NEIGHBOURS:
q = (i + di, j + dj)
if q not in pixels:
continue
if di and dj and ((i + di, j) in pixels or (i, j + dj) in pixels):
continue
links.append(q)
graph[(i, j)] = links
return graph
def trace_skeleton(skeleton, min_spur=0):
"""Polylignes de pixels (ligne, colonne) qui suivent le squelette.
Chaque branche relie deux noeuds (bouts ou carrefours) ; les boucles sans
noeud sont suivies a part ; un pixel isole donne une polyligne d'un point.
Les ergots (branche libre de moins de `min_spur` pixels accrochee a un
carrefour, artefacts de l'amincissement) sont supprimes.
"""
graph = _skeleton_graph(skeleton)
seen = set() # liaisons deja parcourues
def follow(previous, current, line):
seen.add((previous, current))
seen.add((current, previous))
while len(graph[current]) == 2 and current != line[0]:
line.append(current)
a, b = graph[current]
following = b if a == previous else a
if (current, following) in seen:
break
seen.add((current, following))
seen.add((following, current))
previous, current = current, following
line.append(current)
return line
lines = []
for node in sorted(p for p, links in graph.items() if len(links) != 2):
if not graph[node]:
lines.append([node])
for nxt in graph[node]:
if (node, nxt) not in seen:
lines.append(follow(node, nxt, [node]))
for p in sorted(graph): # boucles isolees
links = graph[p]
if len(links) == 2 and (p, links[0]) not in seen:
lines.append(follow(p, links[0], [p]))
if min_spur <= 0:
return lines
degree = {p: len(links) for p, links in graph.items()}
kept = []
for line in lines:
ends = sorted((degree[line[0]], degree[line[-1]]))
if 1 < len(line) <= min_spur and ends[0] == 1 and ends[1] >= 3:
continue
kept.append(line)
return kept
def smooth_polyline(points, passes=2):
"""Lissage par moyenne glissante (1/4, 1/2, 1/4), extremites fixes.
Une boucle fermee (premier point = dernier) est lissee tout du long.
"""
if len(points) < 3:
return [tuple(p) for p in points]
closed = tuple(points[0]) == tuple(points[-1])
pts = np.array(points[:-1] if closed else points, dtype=float)
for _ in range(passes):
if closed:
pts = 0.25 * np.roll(pts, 1, 0) + 0.5 * pts + 0.25 * np.roll(pts, -1, 0)
else:
inner = 0.25 * pts[:-2] + 0.5 * pts[1:-1] + 0.25 * pts[2:]
pts = np.vstack((pts[:1], inner, pts[-1:]))
out = [tuple(p) for p in pts.tolist()]
if closed:
out.append(out[0])
return out
def simplify_polyline(points, tolerance):
"""Ramer-Douglas-Peucker : ne garde que les sommets utiles a `tolerance` pres."""
if len(points) < 3:
return [tuple(p) for p in points]
pts = np.asarray(points, dtype=float)
keep = np.zeros(len(pts), dtype=bool)
keep[0] = keep[-1] = True
stack = [(0, len(pts) - 1)]
while stack:
a, b = stack.pop()
if b - a < 2:
continue
sx, sy = pts[b] - pts[a]
rel = pts[a + 1:b] - pts[a]
length = math.hypot(sx, sy)
if length == 0:
dist = np.hypot(rel[:, 0], rel[:, 1])
else:
dist = np.abs(rel[:, 0] * sy - rel[:, 1] * sx) / length
k = int(np.argmax(dist))
if dist[k] > tolerance:
keep[a + 1 + k] = True
stack.extend(((a, a + 1 + k), (a + 1 + k, b)))
return [tuple(p) for p in pts[keep].tolist()]
def _grid(rings, period, pixels_per_period):
"""Origine, pas et taille (x0, y0, step, nx, ny) de la grille de calcul.
Bordure exterieure de deux periodes : le champ y vaut -1 et l'erosion
par FFT (periodique) ne deborde pas d'un cote sur l'autre.
"""
xs = [x for ring in rings for x, _y in ring]
ys = [y for ring in rings for _x, y in ring]
step = period / pixels_per_period
pad = 2 * pixels_per_period
nx = int(math.ceil((max(xs) - min(xs)) / step)) + 2 * pad
ny = int(math.ceil((max(ys) - min(ys)) / step)) + 2 * pad
return min(xs) - pad * step, min(ys) - pad * step, step, nx, ny
def grid_pixels(rings, period, pixels_per_period=PIXELS_PER_PERIOD):
"""Nombre de pixels de la grille de calcul (0 si rien a calculer)."""
if period <= 0 or not any(rings):
return 0
_x0, _y0, _step, nx, ny = _grid(rings, period, pixels_per_period)
return nx * ny
def turing_pattern(rings, period, line_width, margin=0.0, seed=1, edge="cut",
pixels_per_period=PIXELS_PER_PERIOD, steps=STEPS):
"""Lignes centrales du labyrinthe de Turing qui remplit `rings`.
- period : distance entre les lignes centrales de deux bandes voisines ;
- line_width : epaisseur du trait (bouts ronds compris) : le trait entier
reste dans la forme ;
- margin : espace libre entre le bord de la forme et le trait ;
- seed : graine du tirage aleatoire (autre nombre, autre motif) ;
- edge : "cut", le motif est calcule sans tenir compte de la forme puis
coupe a son bord (comme un tissu decoupe) ; "follow", les bandes
s'arretent avant le bord et le longent.
Renvoie des polylignes en coordonnees du document ; un point isole est
une polyligne de deux points confondus (un trait a bouts ronds le dessine).
"""
if period <= 0 or not any(rings):
return []
x0, y0, step, nx, ny = _grid(rings, period, pixels_per_period)
mask = rasterize(rings, x0, y0, step, nx, ny)
inset = max(0.0, margin) + max(0.0, line_width) / 2
region = erode(mask, inset / step)
if not region.any():
return []
follow = edge == "follow"
u = swift_hohenberg(region.shape, pixels_per_period, seed, steps,
outside=~region if follow else None)
skeleton = skeletonize(u > 0) & region
lines = trace_skeleton(skeleton, min_spur=pixels_per_period / 2)
out = []
for line in lines:
points = [(x0 + (j + 0.5) * step, y0 + (i + 0.5) * step) for i, j in line]
if len(points) == 1:
out.append([points[0], points[0]])
else:
out.append(simplify_polyline(smooth_polyline(points, SMOOTHING), 0.1 * step))
return out
+304
View File
@@ -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/<domaine>.pot depuis le .inx et les .py
python i18n.py update # reporte le modele dans po/<langue>.po
python i18n.py compile # po/<langue>.po -> locale/<langue>/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) :
<name>, attributs gui-text et gui-description, contenu de <option>, <item> et
<label>, sauf translatable="no". Les espaces sont normalises, sauf sous
xml:space="preserve".
"""
import ast
import os
import re
import struct
import sys
import xml.etree.ElementTree as ET
HERE = os.path.dirname(os.path.abspath(__file__))
LANGUAGES = ["en", "fr"]
SOURCE_LANGUAGE = "en"
PO_DIR = os.path.join(HERE, "po")
LOCALE_DIR = os.path.join(HERE, "locale")
XML_SPACE = "{http://www.w3.org/XML/1998/namespace}space"
INX_NS = "{http://www.inkscape.org/namespace/inkscape/extension}"
def _find_inx():
found = sorted(name for name in os.listdir(HERE) if name.endswith(".inx"))
if len(found) != 1:
sys.exit("i18n.py attend un seul fichier .inx dans {} (trouve : {})".format(
HERE, found))
return found[0]
INX = _find_inx()
_INX_ROOT = ET.parse(os.path.join(HERE, INX)).getroot()
DOMAIN = _INX_ROOT.get("translationdomain")
if not DOMAIN:
sys.exit("Attribut translationdomain absent de " + INX)
EXTENSION_NAME = (_INX_ROOT.findtext(INX_NS + "name") or DOMAIN).strip()
SOURCES = [INX] + sorted(
name for name in os.listdir(HERE)
if name.endswith(".py") and name != "i18n.py" and not name.startswith("test"))
# --------------------------------------------------------------------------
# Extraction
# --------------------------------------------------------------------------
def _local(tag):
return tag.rsplit("}", 1)[-1]
def _normalize(text, preserve):
return text if preserve else " ".join(text.split())
def extract_inx(path):
"""Chaines traduisibles d'un fichier .inx, dans l'ordre du document."""
messages = []
def walk(elem, preserve):
preserve = elem.get(XML_SPACE, "preserve" if preserve else "default") == "preserve"
if elem.get("translatable") != "no":
for attr in ("gui-text", "gui-description"):
if elem.get(attr):
messages.append(_normalize(elem.get(attr), preserve))
if _local(elem.tag) in ("name", "option", "item", "label") and elem.text:
messages.append(_normalize(elem.text, preserve))
for child in elem:
walk(child, preserve)
walk(ET.parse(path).getroot(), False)
return [m for m in messages if m]
def extract_py(path):
"""Arguments litteraux des appels _("...") d'un script Python."""
with open(path, encoding="utf-8") as handle:
tree = ast.parse(handle.read(), path)
calls = [node for node in ast.walk(tree)
if isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
and node.func.id == "_" and len(node.args) == 1
and isinstance(node.args[0], ast.Constant)
and isinstance(node.args[0].value, str)]
calls.sort(key=lambda node: (node.lineno, node.col_offset))
return [node.args[0].value for node in calls]
def extract():
"""Liste ordonnee et sans doublon de (msgid, [fichiers sources])."""
found = {}
for name in SOURCES:
path = os.path.join(HERE, name)
strings = extract_inx(path) if name.endswith(".inx") else extract_py(path)
for msgid in strings:
found.setdefault(msgid, [])
if name not in found[msgid]:
found[msgid].append(name)
return list(found.items())
# --------------------------------------------------------------------------
# Lecture / ecriture des fichiers .po
# --------------------------------------------------------------------------
_ESCAPES = {"n": "\n", "t": "\t", '"': '"', "\\": "\\"}
def _unquote(line):
body = line.strip()[1:-1]
return re.sub(r'\\(.)', lambda m: _ESCAPES.get(m.group(1), m.group(1)), body)
def _quote(text):
text = text.replace("\\", "\\\\").replace('"', '\\"').replace("\t", "\\t")
lines = text.split("\n")
parts = [line + "\\n" for line in lines[:-1]]
if lines[-1]:
parts.append(lines[-1])
if len(parts) <= 1:
return '"{}"'.format(parts[0] if parts else "")
return '""\n' + "\n".join('"{}"'.format(part) for part in parts)
def read_po(path):
"""Dictionnaire msgid -> (msgstr, fuzzy). L'en-tete a pour cle ""."""
entries = {}
if not os.path.exists(path):
return entries
msgid = msgstr = None
field = None
fuzzy = False
def flush():
if msgid is not None:
entries[msgid] = (msgstr or "", fuzzy)
with open(path, encoding="utf-8") as handle:
for raw in handle:
line = raw.strip()
if line.startswith("#,") and "fuzzy" in line:
flush()
msgid = msgstr = field = None
fuzzy = True
elif line.startswith("msgid "):
if field == "msgstr":
flush()
fuzzy = False
msgid, msgstr, field = _unquote(line[6:]), None, "msgid"
elif line.startswith("msgstr "):
msgstr, field = _unquote(line[7:]), "msgstr"
elif line.startswith('"') and field == "msgid":
msgid += _unquote(line)
elif line.startswith('"') and field == "msgstr":
msgstr += _unquote(line)
elif not line and field == "msgstr":
flush()
msgid = msgstr = field = None
fuzzy = False
flush()
return entries
def _header(language):
fields = [
("Project-Id-Version", DOMAIN),
("Language", language or ""),
("MIME-Version", "1.0"),
("Content-Type", "text/plain; charset=UTF-8"),
("Content-Transfer-Encoding", "8bit"),
("Plural-Forms", {"fr": "nplurals=2; plural=(n > 1);",
"en": "nplurals=2; plural=(n != 1);"}.get(language, "")),
]
return "".join("{}: {}\n".format(key, value) for key, value in fields if value)
def write_po(path, language, messages, translations):
title = ("Modele de traduction" if language is None
else "Traduction ({})".format(language))
out = ["# {} de l'extension Inkscape « {} ».".format(title, EXTENSION_NAME),
"# Genere par i18n.py ; ne modifier que les msgstr.",
"msgid \"\"",
"msgstr " + _quote(_header(language)),
""]
for msgid, refs in messages:
msgstr, fuzzy = translations.get(msgid, ("", False))
out.append("#: " + " ".join(refs))
if fuzzy:
out.append("#, fuzzy")
out.append("msgid " + _quote(msgid))
out.append("msgstr " + _quote(msgstr))
out.append("")
with open(path, "w", encoding="utf-8", newline="\n") as handle:
handle.write("\n".join(out))
# --------------------------------------------------------------------------
# Compilation .mo (format GNU gettext)
# --------------------------------------------------------------------------
def write_mo(path, catalog):
"""Ecrit un catalogue {msgid: msgstr} au format .mo, cles triees."""
keys = sorted(catalog)
ids = [key.encode("utf-8") for key in keys]
strs = [catalog[key].encode("utf-8") for key in keys]
count = len(keys)
ids_start = 7 * 4 + 16 * count
strs_start = ids_start + sum(len(b) + 1 for b in ids)
table_ids, table_strs = [], []
offset = ids_start
for data in ids:
table_ids += [len(data), offset]
offset += len(data) + 1
offset = strs_start
for data in strs:
table_strs += [len(data), offset]
offset += len(data) + 1
output = struct.pack("<7I", 0x950412DE, 0, count, 7 * 4, 7 * 4 + 8 * count, 0, 0)
output += struct.pack("<{}I".format(2 * count), *table_ids)
output += struct.pack("<{}I".format(2 * count), *table_strs)
output += b"".join(data + b"\0" for data in ids)
output += b"".join(data + b"\0" for data in strs)
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "wb") as handle:
handle.write(output)
# --------------------------------------------------------------------------
# Commandes
# --------------------------------------------------------------------------
def po_path(language):
return os.path.join(PO_DIR, "{}.po".format(language))
def mo_path(language):
return os.path.join(LOCALE_DIR, language, "LC_MESSAGES", DOMAIN + ".mo")
def cmd_extract():
os.makedirs(PO_DIR, exist_ok=True)
messages = extract()
write_po(os.path.join(PO_DIR, DOMAIN + ".pot"), None, messages, {})
print("{} chaines -> po/{}.pot".format(len(messages), DOMAIN))
def cmd_update():
messages = extract()
for language in LANGUAGES:
translations = read_po(po_path(language))
if language == SOURCE_LANGUAGE:
translations = {msgid: (msgid, False) for msgid, _refs in messages}
write_po(po_path(language), language, messages, translations)
missing = [m for m, _r in messages if not translations.get(m, ("", False))[0]]
print("po/{}.po : {} a traduire".format(language, len(missing)))
for msgid in missing:
print(" " + msgid.splitlines()[0])
def cmd_compile():
for language in LANGUAGES:
entries = read_po(po_path(language))
catalog = {msgid: msgstr for msgid, (msgstr, fuzzy) in entries.items()
if msgid and msgstr and not fuzzy}
catalog[""] = _header(language)
write_mo(mo_path(language), catalog)
print("{} -> {} ({} chaines)".format(
os.path.relpath(po_path(language), HERE),
os.path.relpath(mo_path(language), HERE), len(catalog) - 1))
def main(argv):
commands = {"extract": [cmd_extract], "update": [cmd_update],
"compile": [cmd_compile],
"all": [cmd_extract, cmd_update, cmd_compile]}
name = argv[0] if argv else "all"
if name not in commands:
print(__doc__)
return 1
for command in commands[name]:
command()
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
Binary file not shown.

After

Width:  |  Height:  |  Size: 238 KiB

Binary file not shown.
Binary file not shown.
+111
View File
@@ -0,0 +1,111 @@
# Modele de traduction de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: dog_bandana.inx
msgid "Dog Bandana Pattern Fill"
msgstr ""
#: dog_bandana.inx
msgid "Pattern"
msgstr ""
#: dog_bandana.inx
msgid "Period (line spacing, center to center):"
msgstr ""
#: dog_bandana.inx
msgid "Line width:"
msgstr ""
#: dog_bandana.inx
msgid "Margin from the shape edge:"
msgstr ""
#: dog_bandana.inx
msgid "Unit:"
msgstr ""
#: dog_bandana.inx
msgid "Iterations (more = longer, smoother lines):"
msgstr ""
#: dog_bandana.inx
msgid "Few iterations leave many dots and short lines; many iterations give long, regular lines."
msgstr ""
#: dog_bandana.inx
msgid "Random seed (another number, another maze):"
msgstr ""
#: dog_bandana.inx
msgid "At the shape edge:"
msgstr ""
#: dog_bandana.inx
msgid "Cut the lines (like cut fabric)"
msgstr ""
#: dog_bandana.inx
msgid "Lines follow the edge"
msgstr ""
#: dog_bandana.inx
msgid "Style"
msgstr ""
#: dog_bandana.inx
msgid "Line color:"
msgstr ""
#: dog_bandana.inx
msgid "Keep the original shape"
msgstr ""
#: dog_bandana.inx
msgid "Help"
msgstr ""
#: dog_bandana.inx
msgid ""
"Select one or more closed shapes (or groups), then run the extension. Each shape is filled with a Turing maze: winding lines of constant width that branch and end in round tips.\n"
"\n"
"Each line is drawn once, along its center, with a round-capped stroke of the chosen width: ready for line engraving on a laser cutter. The lines are chained and ordered to limit idle travel of the laser head.\n"
"\n"
"Period: distance between the centers of two neighbouring lines. Line width: stroke thickness; keep it below the period (about half gives as much black as white). Margin: free space between the shape edge and the strokes.\n"
"\n"
"Iterations: how long the pattern evolves. Few iterations leave dots and short lines, many give long regular lines. The seed changes the drawing while keeping the same look.\n"
"\n"
"At the shape edge: cut the lines like a piece of fabric, or let them stop before the edge and run along it.\n"
"\n"
"The result is placed in a group just above each shape. Large shapes with a small period take a few seconds."
msgstr ""
#: dog_bandana.py
msgid "Select at least one closed shape (path, rectangle, circle, ellipse, polygon) or a group containing some."
msgstr ""
#: dog_bandana.py
msgid "The period and the line width must be strictly positive."
msgstr ""
#: dog_bandana.py
msgid "The line width must be smaller than the period, otherwise neighbouring lines merge. Reduce the line width or increase the period."
msgstr ""
#: dog_bandana.py
msgid "The shape is too large for this period: the computation would take too long. Increase the period or split the shape."
msgstr ""
#: dog_bandana.py
msgid "{} shape(s) too narrow for the pattern: reduce the line width, the period or the margin."
msgstr ""
#: dog_bandana.py
msgid "Dog Bandana pattern"
msgstr ""
+124
View File
@@ -0,0 +1,124 @@
# Traduction (en) de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
"Language: en\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
#: dog_bandana.inx
msgid "Dog Bandana Pattern Fill"
msgstr "Dog Bandana Pattern Fill"
#: dog_bandana.inx
msgid "Pattern"
msgstr "Pattern"
#: dog_bandana.inx
msgid "Period (line spacing, center to center):"
msgstr "Period (line spacing, center to center):"
#: dog_bandana.inx
msgid "Line width:"
msgstr "Line width:"
#: dog_bandana.inx
msgid "Margin from the shape edge:"
msgstr "Margin from the shape edge:"
#: dog_bandana.inx
msgid "Unit:"
msgstr "Unit:"
#: dog_bandana.inx
msgid "Iterations (more = longer, smoother lines):"
msgstr "Iterations (more = longer, smoother lines):"
#: dog_bandana.inx
msgid "Few iterations leave many dots and short lines; many iterations give long, regular lines."
msgstr "Few iterations leave many dots and short lines; many iterations give long, regular lines."
#: dog_bandana.inx
msgid "Random seed (another number, another maze):"
msgstr "Random seed (another number, another maze):"
#: dog_bandana.inx
msgid "At the shape edge:"
msgstr "At the shape edge:"
#: dog_bandana.inx
msgid "Cut the lines (like cut fabric)"
msgstr "Cut the lines (like cut fabric)"
#: dog_bandana.inx
msgid "Lines follow the edge"
msgstr "Lines follow the edge"
#: dog_bandana.inx
msgid "Style"
msgstr "Style"
#: dog_bandana.inx
msgid "Line color:"
msgstr "Line color:"
#: dog_bandana.inx
msgid "Keep the original shape"
msgstr "Keep the original shape"
#: dog_bandana.inx
msgid "Help"
msgstr "Help"
#: dog_bandana.inx
msgid ""
"Select one or more closed shapes (or groups), then run the extension. Each shape is filled with a Turing maze: winding lines of constant width that branch and end in round tips.\n"
"\n"
"Each line is drawn once, along its center, with a round-capped stroke of the chosen width: ready for line engraving on a laser cutter. The lines are chained and ordered to limit idle travel of the laser head.\n"
"\n"
"Period: distance between the centers of two neighbouring lines. Line width: stroke thickness; keep it below the period (about half gives as much black as white). Margin: free space between the shape edge and the strokes.\n"
"\n"
"Iterations: how long the pattern evolves. Few iterations leave dots and short lines, many give long regular lines. The seed changes the drawing while keeping the same look.\n"
"\n"
"At the shape edge: cut the lines like a piece of fabric, or let them stop before the edge and run along it.\n"
"\n"
"The result is placed in a group just above each shape. Large shapes with a small period take a few seconds."
msgstr ""
"Select one or more closed shapes (or groups), then run the extension. Each shape is filled with a Turing maze: winding lines of constant width that branch and end in round tips.\n"
"\n"
"Each line is drawn once, along its center, with a round-capped stroke of the chosen width: ready for line engraving on a laser cutter. The lines are chained and ordered to limit idle travel of the laser head.\n"
"\n"
"Period: distance between the centers of two neighbouring lines. Line width: stroke thickness; keep it below the period (about half gives as much black as white). Margin: free space between the shape edge and the strokes.\n"
"\n"
"Iterations: how long the pattern evolves. Few iterations leave dots and short lines, many give long regular lines. The seed changes the drawing while keeping the same look.\n"
"\n"
"At the shape edge: cut the lines like a piece of fabric, or let them stop before the edge and run along it.\n"
"\n"
"The result is placed in a group just above each shape. Large shapes with a small period take a few seconds."
#: dog_bandana.py
msgid "Select at least one closed shape (path, rectangle, circle, ellipse, polygon) or a group containing some."
msgstr "Select at least one closed shape (path, rectangle, circle, ellipse, polygon) or a group containing some."
#: dog_bandana.py
msgid "The period and the line width must be strictly positive."
msgstr "The period and the line width must be strictly positive."
#: dog_bandana.py
msgid "The line width must be smaller than the period, otherwise neighbouring lines merge. Reduce the line width or increase the period."
msgstr "The line width must be smaller than the period, otherwise neighbouring lines merge. Reduce the line width or increase the period."
#: dog_bandana.py
msgid "The shape is too large for this period: the computation would take too long. Increase the period or split the shape."
msgstr "The shape is too large for this period: the computation would take too long. Increase the period or split the shape."
#: dog_bandana.py
msgid "{} shape(s) too narrow for the pattern: reduce the line width, the period or the margin."
msgstr "{} shape(s) too narrow for the pattern: reduce the line width, the period or the margin."
#: dog_bandana.py
msgid "Dog Bandana pattern"
msgstr "Dog Bandana pattern"
+124
View File
@@ -0,0 +1,124 @@
# Traduction (fr) de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: dog_bandana.inx
msgid "Dog Bandana Pattern Fill"
msgstr "Remplissage par motif Dog Bandana"
#: dog_bandana.inx
msgid "Pattern"
msgstr "Motif"
#: dog_bandana.inx
msgid "Period (line spacing, center to center):"
msgstr "Période (écart entre les lignes, d'axe en axe) :"
#: dog_bandana.inx
msgid "Line width:"
msgstr "Épaisseur du trait :"
#: dog_bandana.inx
msgid "Margin from the shape edge:"
msgstr "Marge au bord de la forme :"
#: dog_bandana.inx
msgid "Unit:"
msgstr "Unité :"
#: dog_bandana.inx
msgid "Iterations (more = longer, smoother lines):"
msgstr "Itérations (plus = lignes plus longues et régulières) :"
#: dog_bandana.inx
msgid "Few iterations leave many dots and short lines; many iterations give long, regular lines."
msgstr "Peu d'itérations laissent beaucoup de points et de lignes courtes ; beaucoup d'itérations donnent des lignes longues et régulières."
#: dog_bandana.inx
msgid "Random seed (another number, another maze):"
msgstr "Graine aléatoire (autre nombre, autre labyrinthe) :"
#: dog_bandana.inx
msgid "At the shape edge:"
msgstr "Au bord de la forme :"
#: dog_bandana.inx
msgid "Cut the lines (like cut fabric)"
msgstr "Couper les lignes (comme un tissu découpé)"
#: dog_bandana.inx
msgid "Lines follow the edge"
msgstr "Les lignes longent le bord"
#: dog_bandana.inx
msgid "Style"
msgstr "Style"
#: dog_bandana.inx
msgid "Line color:"
msgstr "Couleur du trait :"
#: dog_bandana.inx
msgid "Keep the original shape"
msgstr "Conserver la forme d'origine"
#: dog_bandana.inx
msgid "Help"
msgstr "Aide"
#: dog_bandana.inx
msgid ""
"Select one or more closed shapes (or groups), then run the extension. Each shape is filled with a Turing maze: winding lines of constant width that branch and end in round tips.\n"
"\n"
"Each line is drawn once, along its center, with a round-capped stroke of the chosen width: ready for line engraving on a laser cutter. The lines are chained and ordered to limit idle travel of the laser head.\n"
"\n"
"Period: distance between the centers of two neighbouring lines. Line width: stroke thickness; keep it below the period (about half gives as much black as white). Margin: free space between the shape edge and the strokes.\n"
"\n"
"Iterations: how long the pattern evolves. Few iterations leave dots and short lines, many give long regular lines. The seed changes the drawing while keeping the same look.\n"
"\n"
"At the shape edge: cut the lines like a piece of fabric, or let them stop before the edge and run along it.\n"
"\n"
"The result is placed in a group just above each shape. Large shapes with a small period take a few seconds."
msgstr ""
"Sélectionnez une ou plusieurs formes fermées (ou des groupes), puis lancez l'extension. Chaque forme est remplie d'un labyrinthe de Turing : des lignes sinueuses d'épaisseur constante, qui bifurquent et se terminent en bouts ronds.\n"
"\n"
"Chaque ligne est tracée une seule fois, selon son axe, avec un trait à bouts ronds de l'épaisseur choisie : prête pour la gravure laser en mode ligne. Les lignes sont enchaînées et ordonnées pour limiter les déplacements à vide de la tête du laser.\n"
"\n"
"Période : distance entre les axes de deux lignes voisines. Épaisseur du trait : à garder sous la période (la moitié donne autant de noir que de blanc). Marge : espace libre entre le bord de la forme et les traits.\n"
"\n"
"Itérations : durée d'évolution du motif. Peu d'itérations laissent des points et des lignes courtes, beaucoup donnent de longues lignes régulières. La graine change le dessin en gardant le même aspect.\n"
"\n"
"Au bord de la forme : couper les lignes comme un morceau de tissu, ou les arrêter avant le bord pour qu'elles le longent.\n"
"\n"
"Le résultat est placé dans un groupe juste au-dessus de chaque forme. Une grande forme avec une petite période demande quelques secondes."
#: dog_bandana.py
msgid "Select at least one closed shape (path, rectangle, circle, ellipse, polygon) or a group containing some."
msgstr "Sélectionnez au moins une forme fermée (chemin, rectangle, cercle, ellipse, polygone) ou un groupe qui en contient."
#: dog_bandana.py
msgid "The period and the line width must be strictly positive."
msgstr "La période et l'épaisseur du trait doivent être strictement positives."
#: dog_bandana.py
msgid "The line width must be smaller than the period, otherwise neighbouring lines merge. Reduce the line width or increase the period."
msgstr "L'épaisseur du trait doit être inférieure à la période, sinon les lignes voisines se touchent. Réduisez l'épaisseur ou augmentez la période."
#: dog_bandana.py
msgid "The shape is too large for this period: the computation would take too long. Increase the period or split the shape."
msgstr "La forme est trop grande pour cette période : le calcul serait trop long. Augmentez la période ou découpez la forme."
#: dog_bandana.py
msgid "{} shape(s) too narrow for the pattern: reduce the line width, the period or the margin."
msgstr "{} forme(s) trop étroite(s) pour le motif : réduisez l'épaisseur du trait, la période ou la marge."
#: dog_bandana.py
msgid "Dog Bandana pattern"
msgstr "Motif Dog Bandana"
+359
View File
@@ -0,0 +1,359 @@
# coding=utf-8
"""Tests de l'extension « Dog Bandana » (pytest)."""
import os
import re
import xml.etree.ElementTree as ET
import pytest
import math
import numpy as np
from dog_bandana_core import (chain_polylines, erode, grid_pixels, laser_order,
order_polylines, parse_color, polylines_to_d,
rasterize, simplify_polyline, skeletonize,
smooth_polyline, trace_skeleton, travel_length,
turing_pattern)
HERE = os.path.dirname(os.path.abspath(__file__))
SHAPES = os.path.join(HERE, "tests", "data", "shapes.svg")
SCALED = os.path.join(HERE, "tests", "data", "scaled.svg")
# --------------------------------------------------------------------------
# Noyau (sans inkex)
# --------------------------------------------------------------------------
def test_parse_color_inkscape_integer():
assert parse_color("3014898687") == ("#b3b3b3", 1.0)
assert parse_color(str(0xFF000080)) == ("#ff0000", round(0x80 / 255, 4))
def test_parse_color_hex_and_invalid():
assert parse_color("#123456") == ("#123456", 1.0)
assert parse_color("#abc") == ("#aabbcc", 1.0)
assert parse_color("pas une couleur") == ("#b3b3b3", 1.0)
def test_polylines_to_d():
d = polylines_to_d([[(0, 0), (1, 2)], [(3, 4), (5, 6)]], precision=1)
assert d == "M 0.0,0.0 L 1.0,2.0 M 3.0,4.0 L 5.0,6.0"
def covered_segments(polylines):
"""Segments (arrondis, sens indifferent) couverts par des polylignes."""
out = []
for line in polylines:
for p, q in zip(line, line[1:]):
a, b = tuple(round(v, 6) for v in p), tuple(round(v, 6) for v in q)
out.append(min((a, b), (b, a)))
return sorted(out)
def test_chain_polylines_joins_touching_lines():
# Un « Y » (4 noeuds impairs : 2 traits au minimum) et un trait isole.
y_shape = [[(0, 0), (0, -1)], [(0, 0), (1, 1)], [(-1, 1), (0, 0)]]
lone = [[(5, 5), (6, 5), (7, 6)]]
chained = chain_polylines(y_shape + lone)
assert len(chained) == 3
assert covered_segments(chained) == covered_segments(y_shape + lone)
def test_chain_polylines_closed_circuit():
square = [[(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), (0, 1)], [(0, 1), (0, 0)]]
chained = chain_polylines(square)
assert len(chained) == 1 and len(chained[0]) == 5
assert chained[0][0] == chained[0][-1]
def test_order_polylines_nearest_and_reversed():
lines = [[(10, 0), (20, 0)], [(3, 0), (1, 0)], [(30, 0), (21, 0)]]
ordered = order_polylines(lines, start=(0, 0))
assert ordered == [[(1, 0), (3, 0)], [(10, 0), (20, 0)], [(21, 0), (30, 0)]]
assert travel_length(ordered) == pytest.approx(1 + 7 + 1)
def test_order_polylines_rotates_loops():
loop = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)]
ordered = order_polylines([loop], start=(11, 11))
assert ordered[0][0] == ordered[0][-1] == (10, 10)
assert len(ordered[0]) == 5
def test_laser_order_cuts_travel_on_a_grid():
# Quadrillage de segments unitaires dans un ordre defavorable.
segments = [[(x, y), (x + 1, y)] for x in range(20) for y in range(0, 20, 2)]
segments += [[(x, y), (x, y + 1)] for y in range(20) for x in range(0, 20, 2)]
segments = segments[::2] + segments[1::2]
ordered = laser_order(segments)
assert covered_segments(ordered) == covered_segments(segments)
assert travel_length(ordered) < travel_length(segments) / 4
# --------------------------------------------------------------------------
# Motif de Turing : etapes
# --------------------------------------------------------------------------
def test_rasterize_square_with_hole_even_odd():
outer = [(0, 0), (10, 0), (10, 10), (0, 10)]
hole = [(3, 3), (7, 3), (7, 7), (3, 7)]
mask = rasterize([outer, hole], 0, 0, 1.0, 12, 12)
assert mask.sum() == 100 - 16
assert mask[1, 1] and not mask[5, 5] and not mask[11, 11]
def test_rasterize_vertex_on_scanline_counted_once():
# Sommets de ce losange exactement sur les centres de lignes de pixels.
diamond = [(5, 0.5), (9.5, 5.5), (5, 10.5), (0.5, 5.5)]
mask = rasterize([diamond], 0, 0, 1.0, 10, 11)
for row in mask: # chaque ligne : un seul segment
assert np.count_nonzero(np.diff(row.astype(int))) <= 2
def test_erode_shrinks_by_radius():
mask = np.zeros((40, 40), dtype=bool)
mask[10:30, 10:30] = True
eroded = erode(mask, 3)
rows = np.nonzero(eroded.any(axis=1))[0]
assert rows[0] == 13 and rows[-1] == 26
assert erode(mask, 0).sum() == mask.sum()
def test_skeletonize_bar_to_single_line():
bar = np.zeros((15, 40), dtype=bool)
bar[5:10, 5:35] = True
skeleton = skeletonize(bar)
assert skeleton.any()
assert skeleton.sum(axis=0).max() == 1 # un pixel par colonne
assert (skeleton <= bar).all()
def test_trace_skeleton_line_cross_dot_and_loop():
img = np.zeros((30, 30), dtype=bool)
img[2, 2:12] = True # segment
img[20, 5] = True # point isole
lines = trace_skeleton(img)
assert sorted(len(line) for line in lines) == [1, 10]
cross = np.zeros((21, 21), dtype=bool)
cross[10, :] = True
cross[:, 10] = True
assert len(trace_skeleton(cross)) == 4
loop = np.zeros((12, 12), dtype=bool)
loop[2, 2:9] = loop[8, 2:9] = loop[2:9, 2] = loop[2:9, 8] = True
lines = trace_skeleton(loop)
assert len(lines) == 1 and lines[0][0] == lines[0][-1]
def test_trace_skeleton_prunes_short_spurs():
img = np.zeros((20, 30), dtype=bool)
img[10, 2:28] = True
img[8:10, 15] = True # ergot de 2 pixels
assert len(trace_skeleton(img)) == 3
assert len(trace_skeleton(img, min_spur=4)) == 2
def test_smooth_keeps_ends_and_loops():
zigzag = [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)]
smooth = smooth_polyline(zigzag, 3)
assert smooth[0] == (0, 0) and smooth[-1] == (4, 0)
assert max(y for _x, y in smooth[1:-1]) < 1
loop = [(0, 0), (4, 0), (4, 4), (0, 4), (0, 0)]
smooth = smooth_polyline(loop, 2)
assert smooth[0] == smooth[-1] and len(smooth) == 5
def test_simplify_straight_line():
line = [(x, 0.001 * (x % 2)) for x in range(20)]
assert simplify_polyline(line, 0.01) == [(0.0, 0.0), (19.0, 0.001)]
corner = [(0, 0), (5, 0), (5, 5)]
assert len(simplify_polyline(corner, 0.1)) == 3
# --------------------------------------------------------------------------
# Motif de Turing : resultat
# --------------------------------------------------------------------------
RECT = [[(0, 0), (60, 0), (60, 40), (0, 40)]]
def polyline_length(line):
return sum(math.hypot(q[0] - p[0], q[1] - p[1]) for p, q in zip(line, line[1:]))
@pytest.mark.parametrize("edge", ["cut", "follow"])
def test_pattern_stays_inside_with_margin(edge):
period, width, margin = 4.0, 2.0, 1.5
lines = turing_pattern(RECT, period, width, margin, seed=3, edge=edge)
assert lines
inset = margin + width / 2
tolerance = period / 8 # un pixel de calcul
for line in lines:
for x, y in line:
assert inset - tolerance <= x <= 60 - inset + tolerance
assert inset - tolerance <= y <= 40 - inset + tolerance
def test_pattern_density_matches_period():
"""Longueur des lignes ~ aire / periode : bandes espacees d'une periode."""
period = 4.0
lines = turing_pattern(RECT, period, 2.0, seed=1)
total = sum(polyline_length(line) for line in lines)
ratio = total * period / (60 * 40)
assert 0.6 < ratio < 1.2
def test_pattern_reproducible_and_seeded():
a = turing_pattern(RECT, 4.0, 2.0, seed=7)
assert a == turing_pattern(RECT, 4.0, 2.0, seed=7)
assert a != turing_pattern(RECT, 4.0, 2.0, seed=8)
def test_more_iterations_give_fewer_longer_lines():
few = turing_pattern(RECT, 4.0, 2.0, seed=2, steps=30)
many = turing_pattern(RECT, 4.0, 2.0, seed=2, steps=300)
assert len(many) < len(few)
def test_pattern_respects_holes():
outer = [(0, 0), (60, 0), (60, 60), (0, 60)]
hole = [(20, 20), (40, 20), (40, 40), (20, 40)]
lines = turing_pattern([outer, hole], 4.0, 2.0, seed=1)
inside = [(x, y) for line in lines for x, y in line
if 21.5 < x < 38.5 and 21.5 < y < 38.5]
assert not inside
def test_pattern_empty_cases():
assert turing_pattern([], 4.0, 2.0) == []
assert turing_pattern(RECT, 0, 2.0) == []
# Bande plus etroite que le trait : rien a dessiner.
assert turing_pattern([[(0, 0), (60, 0), (60, 1.5), (0, 1.5)]], 4.0, 2.0) == []
def test_dots_are_two_point_polylines():
lines = turing_pattern(RECT, 4.0, 2.0, seed=1, steps=20)
assert all(len(line) >= 2 for line in lines)
def test_grid_pixels():
assert grid_pixels([], 4.0) == 0
assert grid_pixels(RECT, 4.0) == (120 + 32) * (80 + 32)
def test_laser_order_cuts_travel_on_pattern():
lines = turing_pattern(RECT, 4.0, 2.0, seed=1)
ordered = laser_order(lines)
assert travel_length(ordered) < travel_length(lines) / 3
# --------------------------------------------------------------------------
# Bout en bout (necessite inkex)
# --------------------------------------------------------------------------
def run_extension(tmp_path, *args, source=SHAPES):
pytest.importorskip("inkex")
from dog_bandana import DogBandana
out = tmp_path / "out.svg"
DogBandana().run([*args, "--output={}".format(out), source])
return out.read_text(encoding="utf-8")
def test_end_to_end_default(tmp_path):
svg = run_extension(tmp_path, "--id=rect1")
assert "Dog Bandana pattern" in svg
assert 'id="rect1"' in svg
assert "stroke-linecap:round" in svg
def test_end_to_end_group_and_holes(tmp_path):
svg = run_extension(tmp_path, "--id=group1", "--id=path2")
assert svg.count("Dog Bandana pattern") == 2
@pytest.mark.parametrize("args, message", [
(["--line_width=5", "--period=4"], "smaller than the period"),
(["--margin=30"], "too narrow"),
])
def test_end_to_end_errors(tmp_path, capsys, args, message):
# Document inchange : inkex n'ecrit pas de sortie, seul le message compte.
pytest.importorskip("inkex")
from dog_bandana import DogBandana
DogBandana().run(["--id=rect1", *args,
"--output={}".format(tmp_path / "out.svg"), SHAPES])
assert message in capsys.readouterr().err
def test_end_to_end_non_standard_document_scale(tmp_path):
"""Page de 400 mm pour 538,72 unites : svg.unittouu() s'y tromperait."""
svg = run_extension(tmp_path, "--id=rect1", source=SCALED)
width = re.search(r"stroke-width:([\d.]+)", svg)
assert float(width.group(1)) == pytest.approx(2.0 * 538.72053 / 400, abs=0.001)
def test_end_to_end_removes_original(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--keep_original=false")
assert 'id="rect1"' not in svg
def test_end_to_end_color(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--stroke_color={}".format(0x336699FF))
assert re.search(r"stroke:#336699", svg)
# --------------------------------------------------------------------------
# Traductions
# --------------------------------------------------------------------------
def test_translations_up_to_date_and_complete():
"""Chaque texte du .inx et des .py a sa traduction dans chaque catalogue."""
import gettext
import i18n
msgids = [msgid for msgid, _refs in i18n.extract()]
assert "Dog Bandana Pattern Fill" in msgids
assert "mm" not in msgids # unites marquees translatable="no"
for language in i18n.LANGUAGES:
entries = i18n.read_po(i18n.po_path(language))
missing = [m for m in msgids if not entries.get(m, ("", False))[0]]
assert not missing, "{}.po incomplet : {}".format(language, missing)
catalog = gettext.translation(i18n.DOMAIN, i18n.LOCALE_DIR, [language])
for msgid in msgids:
assert catalog.gettext(msgid) == entries[msgid][0], \
"{} : .mo a recompiler (python i18n.py)".format(language)
def test_po_roundtrip(tmp_path):
import i18n
messages = [("Simple", ["a"]), ('Quote "x" and \\ back', ["a"]),
("Two\nlines", ["a"]), ("Tab\tend\n", ["a"])]
path = str(tmp_path / "xx.po")
i18n.write_po(path, "fr", messages,
{m: ("<" + m + ">", False) for m, _r in messages})
entries = i18n.read_po(path)
for msgid, _refs in messages:
assert entries[msgid] == ("<" + msgid + ">", False)
def test_inx_matches_arguments():
"""Chaque <param> du .inx a son add_argument, et inversement."""
root = ET.parse(os.path.join(HERE, "dog_bandana.inx")).getroot()
params = {elem.get("name") for elem in root.iter()
if elem.tag.rsplit("}", 1)[-1] == "param"}
with open(os.path.join(HERE, "dog_bandana.py"), encoding="utf-8") as handle:
arguments = set(re.findall(r'add_argument\("--(\w+)"', handle.read()))
assert params == arguments
def test_inx_images_exist():
"""Les images de la boite de dialogue sont presentes (chemin relatif au .inx)."""
root = ET.parse(os.path.join(HERE, "dog_bandana.inx")).getroot()
for elem in root.iter():
if elem.tag.rsplit("}", 1)[-1] == "image":
assert os.path.isfile(os.path.join(HERE, elem.text.strip())), elem.text
+6
View File
@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- Echelle non standard (page redimensionnee) : 1 mm = 1,3468 unite utilisateur -->
<svg xmlns="http://www.w3.org/2000/svg" width="400mm" height="400mm"
viewBox="0 0 538.72053 538.72054">
<rect id="rect1" x="100" y="100" width="200" height="100" fill="#e9ecef" stroke="#212529"/>
</svg>

After

Width:  |  Height:  |  Size: 334 B

+13
View File
@@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" width="200mm" height="120mm" viewBox="0 0 200 120">
<rect id="rect1" x="10" y="10" width="50" height="40" fill="#e9ecef" stroke="#212529"/>
<circle id="circle1" cx="100" cy="30" r="22" fill="#e9ecef" stroke="#212529"/>
<path id="path1" d="M 140,10 C 190,0 200,60 160,55 C 130,52 120,30 140,10 Z"
fill="#e9ecef" stroke="#212529"/>
<!-- Forme trouee : le sous-chemin interne est un trou (pair-impair) -->
<path id="path2" d="M 10,65 H 90 V 115 H 10 Z M 35,80 H 65 V 100 H 35 Z"
fill="#e9ecef" fill-rule="evenodd" stroke="#212529"/>
<g id="group1" transform="translate(100,65)">
<ellipse id="ellipse1" cx="45" cy="25" rx="40" ry="20" fill="#e9ecef" stroke="#212529"/>
</g>
</svg>

After

Width:  |  Height:  |  Size: 790 B