commit 00e9ba343457257b5aa2258ec08997ddf1d75e9f Author: Alex Date: Sat Oct 24 20:39:34 2026 +0200 Initiale version diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8aa9a2d --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +# Cache Python et outils +__pycache__/ +*.pyc +.pytest_cache/ +.venv/ + +# Archives de distribution +*.zip + +# SVG intermediaires du schema (regeneres par docs/schema_parametres.py) +docs/*.svg + +# Page de presentation : hors depot (publiee sur le NAS par site/deploy.ps1 ; +# sa configuration contient hote, compte et chemin de cle SSH) +site/ diff --git a/Docs/apercu.png b/Docs/apercu.png new file mode 100644 index 0000000..cbd1725 Binary files /dev/null and b/Docs/apercu.png differ diff --git a/Docs/parametres.png b/Docs/parametres.png new file mode 100644 index 0000000..6572744 Binary files /dev/null and b/Docs/parametres.png differ diff --git a/Docs/schema_parametres.py b/Docs/schema_parametres.py new file mode 100644 index 0000000..cf9493a --- /dev/null +++ b/Docs/schema_parametres.py @@ -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(''.format(pts(points), color, fmt(width), extra)) + + +def motif(polylines, color, width): + for pl in polylines: + polyline(pl, color, width) + + +def text(x, y, s, size=17, color=INK, anchor="start", weight="normal", halo=True): + style = "{};font-size:{}px;font-weight:{};fill:{}".format( + FONT, fmt(size * FS), weight, color) + if halo: + style += ";paint-order:stroke;stroke:#ffffff;stroke-width:5px;stroke-linejoin:round" + out.append('{}'.format( + fmt(x), fmt(y), anchor, style, s)) + + +def note(x, y, lines): + """Legende de bas de panneau, derniere ligne sur la ligne de base `y`.""" + step = 22 * FS + for k, line in enumerate(lines): + text(x, y - (len(lines) - 1 - k) * step, line, size=16, halo=False) + + +def arrow_head(tip, direction, color, size=9): + ux, uy = direction + nx, ny = -uy, ux + base = (tip[0] - size * ux, tip[1] - size * uy) + out.append(''.format(pts([ + tip, (base[0] + 0.45 * size * nx, base[1] + 0.45 * size * ny), + (base[0] - 0.45 * size * nx, base[1] - 0.45 * size * ny)]), color)) + + +def dimension(p, q, offset, label, color=DIM, label_pos=0.5, label_shift=18, size=17): + """Cote entre p et q, decalee de `offset` perpendiculairement.""" + dx, dy = q[0] - p[0], q[1] - p[1] + length = math.hypot(dx, dy) + ux, uy = dx / length, dy / length + nx, ny = -uy, ux + a = (p[0] + offset * nx, p[1] + offset * ny) + b = (q[0] + offset * nx, q[1] + offset * ny) + sign = 1 if offset >= 0 else -1 + for base, end in ((p, a), (q, b)): + polyline([(base[0] + sign * 4 * nx, base[1] + sign * 4 * ny), + (end[0] + sign * 6 * nx, end[1] + sign * 6 * ny)], color, 1, + 'stroke-dasharray="3,3"') + polyline([a, b], color, 1.6) + arrow_head(a, (-ux, -uy), color) + arrow_head(b, (ux, uy), color) + lx = a[0] + label_pos * (b[0] - a[0]) + sign * label_shift * FS * nx + ly = a[1] + label_pos * (b[1] - a[1]) + sign * label_shift * FS * ny + 6 * FS + text(lx, ly, label, size=size, color=color, anchor="middle", weight="bold") + + +def arc(center, radius, a0, a1, color, label=None, label_radius=None, size=16): + """Arc de a0 a a1 degres (sens anti-horaire a l'ecran), fleche au bout.""" + steps = 40 + points = [] + for k in range(steps + 1): + ux, uy = _unit(a0 + (a1 - a0) * k / steps) + points.append((center[0] + radius * ux, center[1] + radius * uy)) + polyline(points[:-2], color, 1.6) + last, before = points[-1], points[-3] + d = math.hypot(last[0] - before[0], last[1] - before[1]) + arrow_head(last, ((last[0] - before[0]) / d, (last[1] - before[1]) / d), color, 8) + if label: + ux, uy = _unit((a0 + a1) / 2) + r = label_radius or radius + 24 + text(center[0] + r * ux, center[1] + r * uy + 6 * FS, label, size=size, + color=color, anchor="middle", weight="bold") + + +def circle_ring(cx, cy, r, n=180): + return [(cx + r * math.cos(2 * math.pi * k / n), cy + r * math.sin(2 * math.pi * k / n)) + for k in range(n)] + + +def panel_title(x, y, number, title): + text(x, y, "{} {}".format(number, title), size=22, weight="bold", halo=False) + + + +# -------------------------------------------------------------------------- +# Panneaux : un par parametre (ou groupe de parametres), numerotes 1 a 4. +# 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(''.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(''.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(''.format(W, H)) + for x1, y1, x2, y2 in ((700, 20, 700, H - 20), (20, 640, W - 20, 640)): + out.append(''.format(x1, y1, x2, y2)) + panel_1() + panel_2() + panel_3() + panel_4() + svg = ('\n' + '\n{2}\n\n').format(W, H, "\n".join(out)) + with open(version["svg"], "w", encoding="utf-8", newline="\n") as handle: + handle.write(svg) + print(version["svg"]) + export_png(version["svg"], version["png"], version["png_width"]) + + +def main(argv): + languages = argv or sorted(VERSIONS) + for language in languages: + build(language) + + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/README.md b/README.md new file mode 100644 index 0000000..4839c78 --- /dev/null +++ b/README.md @@ -0,0 +1,203 @@ +# Dog Bandana — extension Inkscape + + + + + + +
+Formes de test (rectangle, cercle, forme libre, rectangle troué, ellipse) remplies d'un labyrinthe de Turing : lignes noires sinueuses à bouts ronds + + +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. + +
+ +## 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 `` 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`. diff --git a/deploy.ps1 b/deploy.ps1 new file mode 100644 index 0000000..f9f57f5 --- /dev/null +++ b/deploy.ps1 @@ -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\\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..." diff --git a/dog_bandana.inx b/dog_bandana.inx new file mode 100644 index 0000000..52158ef --- /dev/null +++ b/dog_bandana.inx @@ -0,0 +1,79 @@ + + + + Dog Bandana Pattern Fill + fr.alexp.dogbandana + + + + 4.0 + 2.0 + 0.0 + + + + + + + + + + 60 + 1 + + + + + + + + 255 + true + + + + + images/parameters_en.png + + + + + + + + all + + + + + + + diff --git a/dog_bandana.py b/dog_bandana.py new file mode 100644 index 0000000..ae1801c --- /dev/null +++ b/dog_bandana.py @@ -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 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() diff --git a/dog_bandana_core.py b/dog_bandana_core.py new file mode 100644 index 0000000..6a79f36 --- /dev/null +++ b/dog_bandana_core.py @@ -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 diff --git a/i18n.py b/i18n.py new file mode 100644 index 0000000..a800d7f --- /dev/null +++ b/i18n.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python3 +# coding=utf-8 +""" +Chaine de traduction de l'extension, sans dependance a gettext. + + python i18n.py # extract + update + compile + python i18n.py extract # po/.pot depuis le .inx et les .py + python i18n.py update # reporte le modele dans po/.po + python i18n.py compile # po/.po -> locale//LC_MESSAGES/*.mo + +Le domaine est lu dans l'attribut translationdomain du .inx ; les sources sont +le .inx et tous les .py du dossier (hors i18n.py et tests). + +Les textes source (.inx et appels _() des .py) sont en anglais : c'est ce +qu'Inkscape affiche pour une langue sans catalogue. Le catalogue anglais est +rempli automatiquement avec les textes source ; seul fr.po se traduit a la main. + +Les chaines retenues dans le .inx suivent les regles d'Inkscape (inx.its) : +, attributs gui-text et gui-description, contenu de