Linter for inkscape extension

This commit is contained in:
Alex committed 2026-10-24 21:38:03 +02:00
1 parent 00e9ba3434
commit 247ecc3f5a
17 files changed
+1002 -249

No files matched your search

+3
View File
@@ -13,3 +13,6 @@ 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/
# Archives a publier (python package.py)
dist/
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 32 KiB

+57
View File
@@ -0,0 +1,57 @@
#!/usr/bin/env python3
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Generates the icon of the extension for inkscape.org: a disc filled with the
maze computed by dog_bandana_core (same function as the extension).
python docs/make_icon.py # docs/icon.svg + docs/icon.png (256 px)
"""
import math
import os
import subprocess
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(HERE))
from dog_bandana_core import polylines_to_d, turing_pattern # noqa: E402
SIZE = 256
INKSCAPE = [r"C:\Program Files\Inkscape\bin\inkscape.com", "/usr/bin/inkscape",
"/Applications/Inkscape.app/Contents/MacOS/inkscape"]
def main():
center, radius = SIZE / 2, SIZE / 2 - 8
ring = [(center + radius * math.cos(2 * math.pi * k / 180),
center + radius * math.sin(2 * math.pi * k / 180)) for k in range(180)]
period, width = 22, 10
lines = turing_pattern([ring], period, width, margin=6, seed=3, steps=80)
svg = ('<?xml version="1.0" encoding="UTF-8"?>\n'
'<svg xmlns="http://www.w3.org/2000/svg" width="{0}" height="{0}" '
'viewBox="0 0 {0} {0}">\n'
'<circle cx="{1}" cy="{1}" r="{2}" fill="#ffffff" stroke="#212529" '
'stroke-width="6"/>\n'
'<path d="{3}" fill="none" stroke="#212529" stroke-width="{4}" '
'stroke-linecap="round" stroke-linejoin="round"/>\n'
'</svg>\n').format(SIZE, center, radius, polylines_to_d(lines, 2), width)
svg_path = os.path.join(HERE, "icon.svg")
png_path = os.path.join(HERE, "icon.png")
with open(svg_path, "w", encoding="utf-8", newline="\n") as handle:
handle.write(svg)
print(svg_path)
exe = next((path for path in INKSCAPE if os.path.exists(path)), None)
if exe is None:
print("Inkscape not found: export {} by hand".format(svg_path))
return
subprocess.run([exe, svg_path, "--export-type=png", "--export-width={}".format(SIZE),
"--export-filename={}".format(png_path)],
check=True, stderr=subprocess.DEVNULL)
print(png_path)
if __name__ == "__main__":
main()
+37 -35
View File
@@ -1,18 +1,20 @@
#!/usr/bin/env python3
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Genere le schema explicatif des parametres de l'extension.
Generates the diagram that explains the extension parameters.
python docs/schema_parametres.py # les deux versions
python docs/schema_parametres.py # both 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)
# + images/parameters_en.png ("Help"
# tab of the dialog)
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 »).
Shapes are computed by dog_bandana_core (same functions as the extension),
so the diagram stays faithful to the actual result. PNG export goes through
inkscape.com, which waits for the export to finish (unlike the Chocolatey
"inkscape" shim).
"""
import math
@@ -26,21 +28,21 @@ sys.path.insert(0, ROOT)
import dog_bandana_core # noqa: E402
W, H = 1400, 1280 # 4 panneaux de 700 x 640
W, H = 1400, 1280 # 4 panels of 700 x 640
INK = "#343a40" # element principal
GHOST = "#dde1e5" # elements secondaires / voisins
DIM = "#d9480f" # cotes
DIM2 = "#1971c2" # cotes secondaires
EDGE = "#212529" # contour des formes
INK = "#343a40" # main element
GHOST = "#dde1e5" # secondary / neighbouring elements
DIM = "#d9480f" # dimensions
DIM2 = "#1971c2" # secondary dimensions
EDGE = "#212529" # shape outlines
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).
# Version per language: texts, output files, PNG width and text scaling (the
# English version is shown reduced in the dialog: 900 px wide, texts x 1.25 to
# stay readable).
VERSIONS = {
"fr": {
"svg": os.path.join(HERE, "parametres.svg"),
@@ -103,7 +105,7 @@ VERSIONS = {
}
def _unit(angle):
"""Vecteur unitaire, angle en degres, sens anti-horaire a l'ecran (y vers le bas)."""
"""Unit vector, angle in degrees, counterclockwise on screen (y pointing down)."""
a = math.radians(angle)
return math.cos(a), -math.sin(a)
@@ -141,7 +143,7 @@ def text(x, y, s, size=17, color=INK, anchor="start", weight="normal", halo=True
def note(x, y, lines):
"""Legende de bas de panneau, derniere ligne sur la ligne de base `y`."""
"""Panel caption, last line on baseline `y`."""
step = 22 * FS
for k, line in enumerate(lines):
text(x, y - (len(lines) - 1 - k) * step, line, size=16, halo=False)
@@ -157,7 +159,7 @@ def arrow_head(tip, direction, color, size=9):
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."""
"""Dimension between p and q, shifted by `offset` perpendicularly."""
dx, dy = q[0] - p[0], q[1] - p[1]
length = math.hypot(dx, dy)
ux, uy = dx / length, dy / length
@@ -178,7 +180,7 @@ def dimension(p, q, offset, label, color=DIM, label_pos=0.5, label_shift=18, siz
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."""
"""Arc from a0 to a1 degrees (counterclockwise on screen), arrow at the end."""
steps = 40
points = []
for k in range(steps + 1):
@@ -206,12 +208,12 @@ def panel_title(x, y, number, title):
# --------------------------------------------------------------------------
# Panneaux : un par parametre (ou groupe de parametres), numerotes 1 a 4.
# Motifs calcules par dog_bandana_core.turing_pattern, comme dans l'extension.
# Panels: one per parameter (or group of parameters), numbered 1 to 4.
# Patterns computed by dog_bandana_core.turing_pattern, as in the extension.
# --------------------------------------------------------------------------
def strokes(polylines, color, width):
"""Traits a bouts ronds, comme ceux produits par l'extension."""
"""Round-capped strokes, like those produced by the extension."""
for pl in polylines:
out.append('<polyline points="{}" fill="none" stroke="{}" stroke-width="{}" '
'stroke-linecap="round" stroke-linejoin="round"/>'.format(
@@ -230,7 +232,7 @@ def rect_ring(x0, y0, x1, y1):
def crossings(polylines, x):
"""Intersections des polylignes avec la verticale x : (y, pente, numero)."""
"""Crossings of the polylines with the vertical x: (y, slope, index)."""
found = []
for index, pl in enumerate(polylines):
for (ax, ay), (bx, by) in zip(pl, pl[1:]):
@@ -241,16 +243,16 @@ def crossings(polylines, x):
def panel_1():
"""Periode et epaisseur : cotes sur deux lignes voisines bien paralleles."""
"""Period and width: dimensions on two neighbouring, nearly parallel lines."""
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.
# Look for two neighbouring lines, nearly horizontal over a good length
# (verticals x - 70, x, x + 70), about one period apart: the dimensions
# fit in the white space between them.
best = None
for seed in range(1, 9):
lines = dog_bandana_core.turing_pattern([region], period, width, seed=seed,
@@ -272,12 +274,12 @@ def panel_1():
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.
# Period: center to center; width: edge to edge of a single line.
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).
# Width on the lower line, label below it (clear area).
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",
@@ -286,7 +288,7 @@ def panel_1():
def panel_2():
"""Iterations : meme graine, trois durees d'evolution."""
"""Iterations: same seed, three evolution times."""
ox = 700
panel_title(ox + 30, 50, 2, T["title2"])
size, gap = 190, 25
@@ -308,7 +310,7 @@ def panel_2():
def panel_3():
"""Bord de la forme : motif coupe (tissu decoupe) ou qui longe le bord."""
"""Shape edge: pattern cut (like fabric) or running along the edge."""
oy = 640
panel_title(30, oy + 50, 3, T["title3"])
for k, edge in enumerate(("cut", "follow")):
@@ -323,7 +325,7 @@ def panel_3():
def panel_4():
"""Marge : espace libre entre le bord et les traits."""
"""Margin: free space between the edge and the strokes."""
ox, oy = 700, 640
panel_title(ox + 30, oy + 50, 4, T["title4"])
margin, period, width = 40, 30, 14
@@ -342,7 +344,7 @@ def panel_4():
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))
print("Inkscape not found: export {} by hand".format(svg_path))
return
os.makedirs(os.path.dirname(png_path), exist_ok=True)
subprocess.run([exe, svg_path, "--export-type=png",
+340
View File
@@ -0,0 +1,340 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
+134
View File
@@ -0,0 +1,134 @@
# Publication sur inkscape.org
Marche à suivre d'après
[Submitting and Publishing an Inkscape Extension](https://inkscape.gitlab.io/extensions/documentation/authors/submit.html),
et état de chaque point pour la version **1.0.0**.
## 1. Conditions de la page
| Exigence | État |
| -------- | ---- |
| Pas d'accès à Internet, pas d'auto-mise à jour, aucune écriture dans le dossier de configuration | ✅ aucun accès réseau ni fichier écrit (seule la variable `LANGUAGE` du processus est renseignée) |
| Code lisible, en anglais | ✅ commentaires et docstrings des `.py` et du `.inx` en anglais |
| Licence libre, pour le code et les dépendances | ✅ GPL-2.0-or-later (`LICENSE`, en-tête SPDX dans chaque `.py`) ; `numpy` et `lxml` (BSD) sont fournis avec Inkscape |
| Python 3.8 ou plus récent | ✅ grammaire 3.8 vérifiée par `package.py` ; exécuté avec le Python 3.12 d'Inkscape 1.4.4 |
| Dépendances absentes d'Inkscape embarquées | ✅ aucune : `inkex`, `numpy`, `lxml` sont livrés avec Inkscape |
| Un seul zip, toutes plates-formes, fichiers à la racine | ✅ `python package.py` |
| Fonctionne avec au moins une version d'Inkscape | ✅ Inkscape 1.4.4 (Windows) ; autres versions à essayer, voir § 3 |
Contrôles des relecteurs, déjà passés : `.inx` + `.py` présents, licence,
`pytest` (37 tests réussis), `pylint` **9,65/10** (restent des avertissements
« trop d'arguments / de variables locales » sur les fonctions de calcul et
deux suggestions de f-string).
## 2. Construire le paquet
```powershell
python i18n.py # traductions à jour (0 à traduire)
python -m pytest -q # avec PYTHONPATH vers les extensions d'Inkscape : 37 réussis
python docs/make_icon.py # docs/icon.png (256 px), si besoin
python package.py # dist/dog_bandana-1.0.0.zip + .md5
```
Contenu du zip : `dog_bandana.inx`, `dog_bandana.py`, `dog_bandana_core.py`,
`images/parameters_en.png`, `locale/{en,fr}/LC_MESSAGES/dogbandana.mo`,
`LICENSE`, `README.en.md`.
La version vient de `__version__` dans `dog_bandana_core.py` : l'augmenter à
chaque nouvelle publication.
## 3. Essayer le zip dans Inkscape (à faire pour chaque version annoncée)
Profil vierge, pour ne pas mélanger avec l'extension déjà déployée :
```powershell
$env:INKSCAPE_PROFILE_DIR = "$env:TEMP\inkscape-test-profile"
& 'C:\Program Files\Inkscape\bin\inkscape.exe'
```
Puis **Extensions › Gérer les extensions…**, deuxième onglet, bouton dossier
en bas, choisir `dist\dog_bandana-1.0.0.zip`. Redémarrer Inkscape (même
variable), dessiner une forme, lancer l'extension. Fermer, puis
`Remove-Item Env:INKSCAPE_PROFILE_DIR`.
Déjà vérifié : le zip installé dans un profil vierge d'Inkscape 1.4.4 est
chargé, ses paramètres sont transmis et ses messages sont en français ; le
calcul tourne avec le Python et le numpy d'Inkscape. Reste à faire à la main :
l'installation par le gestionnaire d'extensions et un essai sur la sélection
dans l'interface (Inkscape en ligne de commande ne transmet pas la sélection
aux effets). Si d'autres versions (1.2, 1.3…) sont disponibles, les essayer
et les noter pour les étiquettes de compatibilité.
## 4. Signer le zip
Méthode recommandée : signature GnuPG détachée, avec la clé publique déposée
dans le profil inkscape.org (aucune clé secrète n'existe encore sur ce poste) :
```powershell
gpg --full-generate-key # une seule fois
gpg --armor --export <ton e-mail> # à coller dans le profil inkscape.org
python package.py --sign # dist/dog_bandana-1.0.0.sig
```
À défaut (moins sûr) : l'empreinte md5 de `dist/dog_bandana-1.0.0.zip.md5`
(il faut alors un texte quelconque dans le champ signature de la clé GnuPG du
profil inkscape.org pour que le champ md5 apparaisse).
## 5. Déposer sur inkscape.org
Rubrique **Extensions** de la galerie, avec :
- le zip et sa signature (`.sig`, ou le md5) ;
- l'icône `docs/icon.png` et une capture : `docs/apercu.png`, idéalement
remplacée par une vraie capture d'Inkscape (boîte de dialogue + résultat) ;
- les versions d'Inkscape essayées (au moins **1.4**) ;
- le lien du dépôt : https://git.alex-design.fr/Alex/inkscape.motif.DogBandana
(le dépôt doit être public et contenir le code avant la demande de relecture) ;
- le titre et la description ci-dessous (en anglais, exigé).
**Titre**
```text
Dog Bandana Pattern Fill
```
**Description**
```text
Fills the selected shapes with a Turing maze: winding lines of constant width
that branch, sometimes close into loops, and end in round tips (the "noodle"
pattern often seen on dog bandanas).
The pattern is computed with the Swift-Hohenberg equation (labyrinth regime)
on a grid covering each shape, then reduced to the center line of every band:
one round-capped stroke per noodle, ready for line engraving on a laser
cutter. Strokes are chained and ordered by nearest neighbour to minimise idle
travel of the laser head (on a 300 x 200 mm rectangle, idle travel drops from
71.7 m to 4.2 m).
Works on paths, rectangles, circles, ellipses and polygons, also inside
groups, with holes respected. Settings: period (line spacing), line width,
margin from the edge, unit, iterations (few: dots and short lines; many: long
regular lines), random seed, and edge behaviour (lines cut like fabric, or
running along the edge). The result is placed in a group above each shape.
Menu: Extensions > AlexDesign > Dog Bandana Pattern Fill.
Interface in English and French. No extra dependency: uses inkex and numpy,
shipped with Inkscape. Tested with Inkscape 1.4.
License: GPL-2.0-or-later.
```
## 6. Demander la relecture
Message sur le canal RocketChat **inkscape_extensions**
(https://chat.inkscape.org/channel/inkscape_extensions), par exemple :
```text
Hello! I uploaded "Dog Bandana Pattern Fill" (version 1.0.0) to the extensions
gallery and would like to request a review. It fills shapes with a Turing maze
drawn as round-capped center lines, for laser engraving. Pure Python
(inkex + numpy), GPL-2.0-or-later, pytest suite included in the repository:
https://git.alex-design.fr/Alex/inkscape.motif.DogBandana
Gallery page: <link to the upload>
Thanks!
```
+67
View File
@@ -0,0 +1,67 @@
# Dog Bandana Pattern Fill — Inkscape extension
Inkscape 1.x extension that fills the selected shapes with a **Turing maze**:
winding lines of constant width that branch, sometimes close into loops, and
end in round tips — the "noodle" pattern often seen on dog bandanas.
The pattern is computed (Swift-Hohenberg equation, labyrinth regime) on a grid
covering the shape, then reduced to the **center line** of each band: a single
round-capped stroke per noodle, ready for line engraving on a laser cutter, in
an order that limits the idle travel of the laser head.
![Parameters](images/parameters_en.png)
## Features
- Fills paths, rectangles, circles, ellipses and polygons, also inside groups
(transforms included); holes are respected (even-odd rule).
- One `<path>` per shape, `stroke-linecap:round`; the whole stroke (round tips
included) stays inside the shape, minus the margin.
- At the shape edge: lines **cut** like a piece of fabric (default), or lines
that **follow** the edge.
- Adjustable look: few iterations give dots and short lines, many give long
regular lines; the random seed changes the drawing, not its look. Same seed,
same result.
- Optimized engraving order: touching strokes are chained, then ordered by
nearest neighbour. On a 300 × 200 mm rectangle (4 mm period), idle travel
drops from 71,690 mm to 4,179 mm. Disable the reoptimization of your laser
software (LightBurn…) to keep this order.
- About 1 s for 150 × 100 mm, 4 s for 300 × 200 mm (4 mm period).
- Interface in English and French, following Inkscape's language.
## Installation
No external dependency: the extension uses `inkex` and `numpy`, shipped with
Inkscape.
- **Extension Manager**: *Extensions › Manage Extensions…*, second tab, folder
button at the bottom, pick the zip.
- **By hand**: unzip into a subfolder of the user extensions folder
(*Edit › Preferences › System › User extensions*), then restart Inkscape.
## Usage
1. Select one or more closed shapes (or groups).
2. *Extensions › AlexDesign › Dog Bandana Pattern Fill*.
3. Set period, line width, margin, iterations, seed and edge behaviour in the
**Pattern** tab, color and "keep the original shape" in **Style**.
4. Apply: the pattern is placed in a group just above each shape.
| Parameter | Default | Role |
| ------------------ | ------------------ | ------------------------------------------------------- |
| Period | 4 mm | Distance between the centers of two neighbouring lines |
| Line width | 2 mm | Stroke width; must stay below the period |
| Margin | 0 | Free space between the shape edge and the strokes |
| Unit | mm | mm, cm, px, pt, in |
| Iterations | 60 | Few: dots and short lines; many: long regular lines |
| Random seed | 1 | Changes the drawing, not its look |
| At the shape edge | Cut the lines | Cut like fabric, or follow the edge |
| Line color | black | Stroke color and opacity |
| Keep the original | yes | Otherwise the source shape is deleted |
## License
GPL-2.0-or-later — see [LICENSE](LICENSE).
Source code, tests and French documentation:
https://git.alex-design.fr/Alex/inkscape.motif.DogBandana
+25 -1
View File
@@ -29,6 +29,7 @@ ligne, dans un ordre qui limite les déplacements à vide de la tête.
- [Paramètres](#paramètres)
- [Structure du projet](#structure-du-projet)
- [Développement](#développement)
- [Licence](#licence)
## Fonctionnalités
@@ -137,11 +138,16 @@ 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/apercu.png Aperçu du résultat (bandeau du README, capture inkscape.org)
docs/make_icon.py Générateur de l'icône de la galerie (docs/icon.png)
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
package.py Zip à publier sur inkscape.org (dist/)
PUBLICATION.md Marche à suivre pour inkscape.org
README.en.md README anglais (livré dans le zip)
LICENSE GPL-2.0
```
API du module `dog_bandana_core` :
@@ -201,3 +207,21 @@ python docs/schema_parametres.py # fr → docs/parametres.png (1400 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`.
### Publication sur inkscape.org
```bash
python docs/make_icon.py # docs/icon.png, icône de la galerie
python package.py # dist/dog_bandana-<version>.zip + .md5
python package.py --sign # + signature GnuPG détachée (.sig)
```
`package.py` vérifie la compatibilité Python 3.8 des fichiers livrés et la
présence des traductions compilées. Marche à suivre complète, description
anglaise à coller et état des exigences : [PUBLICATION.md](PUBLICATION.md).
Les commentaires du code sont en anglais, comme l'exige la relecture
d'inkscape.org.
## Licence
GPL-2.0-or-later — voir [LICENSE](LICENSE).
+12 -9
View File
@@ -1,8 +1,11 @@
<?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.
SPDX-License-Identifier: GPL-2.0-or-later
Copyright (C) 2026 Alex
Source texts in English, translated by the "dogbandana" catalog
(locale/<language>/LC_MESSAGES/dogbandana.mo). After changing any text:
python i18n.py, then fill in po/fr.po and run it again.
-->
<inkscape-extension translationdomain="dogbandana"
xmlns="http://www.inkscape.org/namespace/inkscape/extension">
@@ -18,7 +21,7 @@
<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 -->
<!-- Units are not translated -->
<option translatable="no" value="mm">mm</option>
<option translatable="no" value="cm">cm</option>
<option translatable="no" value="px">px</option>
@@ -45,13 +48,13 @@
</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. -->
<!-- Diagram generated by docs/schema_parametres.py, in English:
Inkscape does not translate an image path. Shown at 3/4 of
the PNG size (900 px) to limit the height of the tab. -->
<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. -->
<!-- One paragraph per line: Inkscape wraps it to the tab width;
manual line breaks would leave a narrow column. -->
<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.
+50 -41
View File
@@ -1,16 +1,21 @@
#!/usr/bin/env python3
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Extension Inkscape : remplit les formes selectionnees d'un labyrinthe de
Turing (motif « Dog Bandana »), trace en lignes centrales a bouts ronds.
Inkscape extension: fills the selected shapes with a Turing maze ("Dog
Bandana" pattern), drawn as round-capped center lines.
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.
The pattern is computed with the Swift-Hohenberg equation on a grid covering
the shape, then reduced to the center line of each band: one stroke per
"noodle", ready for line engraving on a laser cutter.
La logique vit dans `dog_bandana_core`, sans dependance a inkex.
The logic lives in `dog_bandana_core`, which does not depend on inkex.
"""
import builtins
import ctypes
import locale
import os
import sys
@@ -19,60 +24,60 @@ 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.
# The extension lives in its own subfolder of Inkscape's extensions, which is
# not necessarily in sys.path: add it so that dog_bandana_core can be found.
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
# pylint: disable-next=wrong-import-position
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.
"""Set LANGUAGE to the system language if nothing sets it already.
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.
On Windows, Inkscape set to "system language" passes no language
variable to the script: gettext would fall back to English while the
dialog, translated by Inkscape itself, is in the user's language.
"""
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
return # outside Windows, LANG is always set
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.
# Installs _() in the builtins: "dogbandana" catalog of the interface
# language (Inkscape passes domain and folder through the environment),
# original English texts otherwise.
use_system_language()
localize()
# Explicit module-level name for the function localize() installed, so that
# linters do not report _ as undefined.
_ = builtins.__dict__["_"]
# Elements qui delimitent une surface a remplir.
# Elements that delimit an area to fill.
SHAPES = (inkex.PathElement, inkex.Rectangle, inkex.Circle, inkex.Ellipse,
inkex.Polygon)
def uu_per_mm(svg):
"""Unites utilisateur par millimetre, comme Inkscape les affiche.
"""User units per millimeter, as Inkscape displays them.
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.
svg.unittouu() guesses the document unit by rounding to the nearest
known unit: it is wrong as soon as the scale is not standard (resized
page). We take the actual page / viewBox ratio; Inkscape applies a
uniform scale (preserveAspectRatio "meet"), i.e. the smaller of the two.
"""
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
except AttributeError: # inkex older than 1.2
return svg.unittouu("1mm")
if not (vb_w and vb_h and page_w and page_h):
return svg.unittouu("1mm")
@@ -80,14 +85,14 @@ def uu_per_mm(svg):
def length_to_uu(svg, value, unit="mm"):
"""Longueur reelle (valeur + unite) -> unites utilisateur du document."""
"""Real length (value + unit) -> document user units."""
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.
"""Outline of the element in absolute coordinates: list of rings.
Les courbes sont aplaties en polylignes (ecart maximal `flatness`).
Curves are flattened into polylines (maximum deviation `flatness`).
"""
path = elem.path.transform(elem.composed_transform())
csp = path.to_superpath()
@@ -103,10 +108,16 @@ def element_rings(elem, flatness):
class DogBandana(inkex.EffectExtension):
"""Remplit chaque forme selectionnee d'un labyrinthe de Turing."""
"""Fills each selected shape with a Turing maze."""
def __init__(self):
super().__init__()
# Position of the laser head: each drawing starts where the previous
# one stopped (see path_element).
self.head = (0.0, 0.0)
def add_arguments(self, pars):
# Un argument par <param> du .inx, memes noms et memes valeurs par defaut.
# One argument per <param> of the .inx, same names and same defaults.
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)
@@ -154,8 +165,6 @@ class DogBandana(inkex.EffectExtension):
"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:
@@ -172,11 +181,11 @@ class DogBandana(inkex.EffectExtension):
"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.
"""SVG path of the strokes, in optimized engraving order.
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.
Touching strokes are chained, then ordered as close as possible to
the head position: less idle travel for the laser. Every generated
stroke goes through here.
"""
polylines = laser_order(polylines, self.head)
if polylines:
@@ -187,7 +196,7 @@ class DogBandana(inkex.EffectExtension):
return node
def process(self, elem, rings, period, width, margin, style):
"""Remplit un element ; renvoie False si la forme est trop etroite."""
"""Fill one element; return False if the shape is too narrow."""
opt = self.options
polylines = turing_pattern(rings, period, width, margin, seed=opt.seed,
edge=opt.edge, steps=opt.iterations)
@@ -198,8 +207,8 @@ class DogBandana(inkex.EffectExtension):
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.
# The result is computed in absolute document coordinates: cancel
# the transform inherited from the host parent.
parent_transform = parent.composed_transform()
if parent_transform != inkex.Transform():
group.transform = -parent_transform
+105 -102
View File
@@ -1,37 +1,40 @@
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Noyau de calcul de l'extension « Dog Bandana », sans dependance a inkex.
Computation core of the "Dog Bandana Pattern Fill" extension, without inkex.
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
des parametres).
Testable with pytest alone and reusable outside Inkscape (scripts, parameter
diagram).
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).
Conventions:
- an outline (`rings`) is a list of rings, each ring being a list of (x, y)
points, implicitly closed; holes follow the even-odd rule;
- a polyline is a list of (x, y) points;
- the y axis points down (SVG coordinates).
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).
The pattern is a Turing maze (bands of constant width that wind, branch and
end in round tips): `turing_pattern` returns the center line of each band,
to be drawn with a round-capped stroke. Only dependency: numpy, shipped with
Inkscape (inkex depends on it).
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.
Generated strokes go through `laser_order` before being written: they are
chained and ordered to limit the idle travel of the laser head.
"""
import math
import numpy as np
__version__ = "1.0.0"
def parse_color(value, default=("#b3b3b3", 1.0)):
"""Couleur Inkscape (entier RGBA decimal ou 0x..., ou #rrggbb[aa]).
"""Inkscape color (decimal RGBA integer or 0x..., or #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.
Returns (CSS color #rrggbb, opacity between 0 and 1). Inkscape's "color"
parameter arrives as an RGBA integer; we decode it ourselves so as not to
depend on inkex's color API, which changed across 1.x versions.
"""
text = str(value).strip()
try:
@@ -55,7 +58,7 @@ def parse_color(value, default=("#b3b3b3", 1.0)):
def polylines_to_d(polylines, precision=4):
"""Donnees `d` d'un chemin SVG : une polyligne par sous-chemin."""
"""`d` data of an SVG path: one polyline per subpath."""
fmt = "{:.%df},{:.%df}" % (precision, precision)
parts = []
for polyline in polylines:
@@ -67,11 +70,11 @@ def polylines_to_d(polylines, precision=4):
# --------------------------------------------------------------------------
# Ordre de gravure (decoupeuse laser)
# Engraving order (laser cutter)
# --------------------------------------------------------------------------
def _key(point):
"""Cle d'un point : deux extremites a 1e-6 pres sont le meme noeud."""
"""Key of a point: two end points within 1e-6 are the same node."""
return round(point[0], 6), round(point[1], 6)
@@ -80,18 +83,18 @@ def _is_closed(line):
def chain_polylines(polylines):
"""Met bout a bout les polylignes qui se touchent par leurs extremites.
"""Join end to end the polylines that touch at their end points.
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.
The laser then follows each result in one stroke, without lifting.
Polylines are the edges of a graph whose nodes are their end points;
walks start from odd-degree nodes first (branch tips): a walk starting
there can only stop on another odd node, which limits the number of
strokes, hence of idle jumps. An already closed polyline (loop) is kept
as is.
"""
out = []
points = {}
adjacency = {} # noeud -> [(numero de polyligne, voisin)]
adjacency = {} # node -> [(polyline index, neighbour)]
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])
@@ -126,25 +129,25 @@ def chain_polylines(polylines):
for node in adjacency:
if len(free_edges(node)) % 2:
out.append(walk(node))
for node in adjacency: # reste : circuits fermes
for node in adjacency: # what remains: closed circuits
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.
"""Order the polylines to limit the idle travel of the 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.
Nearest neighbour: from the end of the previous polyline (or `start`),
continue with the closest free entry point. An open polyline can be
followed in either direction; a closed loop can start at any of its
vertices. Entry points are stored in a grid so that not everything is
compared at each step.
"""
polylines = [list(line) for line in polylines if len(line) >= 2]
if not polylines:
return []
entries = [] # (numero de polyligne, sommet d'entree)
entries = [] # (polyline index, entry vertex)
for index, line in enumerate(polylines):
if _is_closed(line):
entries.extend((index, k) for k in range(len(line) - 1))
@@ -164,7 +167,7 @@ def order_polylines(polylines, start=(0.0, 0.0)):
done = [False] * len(polylines)
def ring(cx, cy, r):
"""Cellules de la grille a distance r (en cellules) de (cx, cy)."""
"""Grid cells at distance r (in cells) from (cx, cy)."""
if r == 0:
yield cx, cy
return
@@ -182,7 +185,7 @@ def order_polylines(polylines, start=(0.0, 0.0)):
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(0, -cx, cx - nx, -cy, cy - ny) # first ring inside the grid
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:
@@ -209,7 +212,7 @@ def order_polylines(polylines, start=(0.0, 0.0)):
pass
elif not _is_closed(line):
line = line[::-1]
else: # boucle : rotation
else: # loop: rotate it
line = line[k:-1] + line[:k] + [line[k]]
ordered.append(line)
position = line[-1]
@@ -217,16 +220,16 @@ def order_polylines(polylines, start=(0.0, 0.0)):
def laser_order(polylines, start=(0.0, 0.0)):
"""Enchaine puis ordonne les traits : a appliquer avant polylines_to_d.
"""Chain then order the strokes: apply before 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.
`start`: position of the head (end of the previous drawing, or origin).
The final position is the last point of the last polyline.
"""
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 length of idle moves (head off) between polylines."""
total = 0.0
position = start
for line in polylines:
@@ -236,30 +239,30 @@ def travel_length(polylines, start=(0.0, 0.0)):
# --------------------------------------------------------------------------
# Motif de Turing (labyrinthe)
# Turing pattern (maze)
# --------------------------------------------------------------------------
#
# 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.
# "Labyrinth" regime of the Swift-Hohenberg equation:
# du/dt = r.u - (1 + laplacian)^2 u - u^3
# integrated on a pixel grid covering the shape. Starting from random noise,
# the field u organizes into bands of period 2.pi (reduced units). Positive
# bands are thinned to a one-pixel skeleton, traced as polylines, smoothed
# and simplified.
PIXELS_PER_PERIOD = 8 # resolution du calcul
STEPS = 60 # pas d'integration : plus, bandes plus longues
SMOOTHING = 4 # passes de lissage des lignes centrales
PIXELS_PER_PERIOD = 8 # computation resolution
STEPS = 60 # integration steps: more, longer bands
SMOOTHING = 4 # smoothing passes of the center lines
EDGE_MODES = ("cut", "follow")
MAX_PIXELS = 3000000 # au-dela, calcul trop long dans Inkscape
MAX_PIXELS = 3000000 # beyond this, too slow inside Inkscape
def rasterize(rings, x0, y0, step, nx, ny):
"""Masque booleen (ny, nx) des centres de pixels interieurs (pair-impair).
"""Boolean mask (ny, nx) of pixel centers inside the rings (even-odd).
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.
Pixel (i, j): center at (x0 + (j + 0.5) * step, y0 + (i + 0.5) * step).
Scanline fill: for each row, sorted abscissas of the crossings with the
edges; a pixel is inside if it has an odd number of crossings on its
left.
"""
mask = np.zeros((ny, nx), dtype=bool)
edges = [(ring[k], ring[(k + 1) % len(ring)]) for ring in rings
@@ -271,7 +274,7 @@ def rasterize(rings, x0, y0, step, nx, ny):
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.
# Half-open edge: a shared vertex is counted only once.
hit = (ay <= y) != (by <= y)
if not hit.any():
continue
@@ -282,11 +285,11 @@ def rasterize(rings, x0, y0, step, nx, ny):
def erode(mask, radius):
"""Erosion du masque par un disque de `radius` pixels.
"""Erosion of the mask by a disk of `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.
FFT convolution: a pixel stays if there is no outside pixel in the disk
around it. The convolution is periodic: the grid must keep an outer
border of at least `radius` pixels.
"""
if radius <= 0:
return mask.copy()
@@ -301,18 +304,18 @@ def erode(mask, radius):
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.
"""Field u (ny, nx) in the labyrinth regime.
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.
Semi-implicit spectral scheme: implicit linear part (stable whatever the
time step), explicit cubic term; periodic boundaries. `outside`
(optional boolean mask): pixels where u is forced to -1 at each step;
bands then stop before this mask and run along its edge, instead of
being cut sharply.
"""
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
spacing = 2 * math.pi / pixels_per_period # pixel in reduced units
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
@@ -328,7 +331,7 @@ def swift_hohenberg(shape, pixels_per_period=PIXELS_PER_PERIOD, seed=1,
def skeletonize(binary):
"""Squelette d'un pixel d'epaisseur (Zhang-Suen), vectorise avec numpy."""
"""One-pixel-wide skeleton (Zhang-Suen), vectorized with numpy."""
img = np.pad(binary.astype(np.uint8), 1)
while True:
changed = False
@@ -357,10 +360,10 @@ _NEIGHBOURS = ((-1, 0), (0, 1), (1, 0), (0, -1), (-1, -1), (-1, 1), (1, 1), (1,
def _skeleton_graph(skeleton):
"""Voisins de chaque pixel du squelette.
"""Neighbours of each skeleton pixel.
Liaisons 8-connexes, sauf une diagonale doublee par deux liaisons droites
(coin en « L ») : elle creerait de faux carrefours.
8-connected links, except a diagonal doubled by two straight links
("L" corner): it would create false junctions.
"""
pixels = set(zip(*(index.tolist() for index in np.nonzero(skeleton))))
graph = {}
@@ -378,15 +381,15 @@ def _skeleton_graph(skeleton):
def trace_skeleton(skeleton, min_spur=0):
"""Polylignes de pixels (ligne, colonne) qui suivent le squelette.
"""Polylines of pixels (row, column) that follow the skeleton.
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.
Each branch joins two nodes (tips or junctions); loops without a node
are traced separately; an isolated pixel gives a one-point polyline.
Spurs (free branch shorter than `min_spur` pixels attached to a junction,
thinning artifacts) are removed.
"""
graph = _skeleton_graph(skeleton)
seen = set() # liaisons deja parcourues
seen = set() # links already followed
def follow(previous, current, line):
seen.add((previous, current))
@@ -410,7 +413,7 @@ def trace_skeleton(skeleton, min_spur=0):
for nxt in graph[node]:
if (node, nxt) not in seen:
lines.append(follow(node, nxt, [node]))
for p in sorted(graph): # boucles isolees
for p in sorted(graph): # isolated loops
links = graph[p]
if len(links) == 2 and (p, links[0]) not in seen:
lines.append(follow(p, links[0], [p]))
@@ -428,9 +431,9 @@ def trace_skeleton(skeleton, min_spur=0):
def smooth_polyline(points, passes=2):
"""Lissage par moyenne glissante (1/4, 1/2, 1/4), extremites fixes.
"""Moving-average smoothing (1/4, 1/2, 1/4), end points fixed.
Une boucle fermee (premier point = dernier) est lissee tout du long.
A closed loop (first point = last point) is smoothed all along.
"""
if len(points) < 3:
return [tuple(p) for p in points]
@@ -449,7 +452,7 @@ def smooth_polyline(points, passes=2):
def simplify_polyline(points, tolerance):
"""Ramer-Douglas-Peucker : ne garde que les sommets utiles a `tolerance` pres."""
"""Ramer-Douglas-Peucker: keep only the vertices needed within `tolerance`."""
if len(points) < 3:
return [tuple(p) for p in points]
pts = np.asarray(points, dtype=float)
@@ -475,10 +478,10 @@ def simplify_polyline(points, tolerance):
def _grid(rings, period, pixels_per_period):
"""Origine, pas et taille (x0, y0, step, nx, ny) de la grille de calcul.
"""Origin, step and size (x0, y0, step, nx, ny) of the computation grid.
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.
Outer border of two periods: the field is -1 there and the (periodic)
FFT erosion does not leak from one side to the other.
"""
xs = [x for ring in rings for x, _y in ring]
ys = [y for ring in rings for _x, y in ring]
@@ -490,7 +493,7 @@ def _grid(rings, period, pixels_per_period):
def grid_pixels(rings, period, pixels_per_period=PIXELS_PER_PERIOD):
"""Nombre de pixels de la grille de calcul (0 si rien a calculer)."""
"""Number of pixels of the computation grid (0 if nothing to compute)."""
if period <= 0 or not any(rings):
return 0
_x0, _y0, _step, nx, ny = _grid(rings, period, pixels_per_period)
@@ -499,19 +502,19 @@ def grid_pixels(rings, period, pixels_per_period=PIXELS_PER_PERIOD):
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`.
"""Center lines of the Turing maze that fills `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.
- period: distance between the center lines of two neighbouring bands;
- line_width: stroke width (round tips included): the whole stroke stays
inside the shape;
- margin: free space between the shape edge and the stroke;
- seed: random seed (another number, another pattern);
- edge: "cut", the pattern is computed regardless of the shape then cut
at its edge (like cut fabric); "follow", bands stop before the edge
and run along it.
Renvoie des polylignes en coordonnees du document ; un point isole est
une polyligne de deux points confondus (un trait a bouts ronds le dessine).
Returns polylines in document coordinates; an isolated dot is a polyline
of two identical points (a round-capped stroke draws it).
"""
if period <= 0 or not any(rings):
return []
+32 -29
View File
@@ -1,23 +1,26 @@
#!/usr/bin/env python3
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Chaine de traduction de l'extension, sans dependance a gettext.
Translation toolchain of the extension, without depending on gettext tools.
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
python i18n.py extract # po/<domain>.pot from the .inx and the .py files
python i18n.py update # merge the template into po/<language>.po
python i18n.py compile # po/<language>.po -> locale/<language>/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).
The domain is read from the translationdomain attribute of the .inx; the
sources are the .inx and every .py file of the folder (except i18n.py and
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.
Source texts (.inx and _() calls in the .py files) are in English: this is
what Inkscape shows for a language without a catalog. The English catalog is
filled automatically with the source texts; only fr.po is translated by hand.
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
Strings taken from the .inx follow Inkscape's rules (inx.its): <name>,
gui-text and gui-description attributes, content of <option>, <item> and
<label>, unless translatable="no". Whitespace is normalized, except under
xml:space="preserve".
"""
@@ -41,7 +44,7 @@ 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(
sys.exit("i18n.py expects exactly one .inx file in {} (found: {})".format(
HERE, found))
return found[0]
@@ -50,7 +53,7 @@ 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)
sys.exit("translationdomain attribute missing from " + INX)
EXTENSION_NAME = (_INX_ROOT.findtext(INX_NS + "name") or DOMAIN).strip()
SOURCES = [INX] + sorted(
name for name in os.listdir(HERE)
@@ -70,7 +73,7 @@ def _normalize(text, preserve):
def extract_inx(path):
"""Chaines traduisibles d'un fichier .inx, dans l'ordre du document."""
"""Translatable strings of a .inx file, in document order."""
messages = []
def walk(elem, preserve):
@@ -89,7 +92,7 @@ def extract_inx(path):
def extract_py(path):
"""Arguments litteraux des appels _("...") d'un script Python."""
"""Literal arguments of the _("...") calls of a Python script."""
with open(path, encoding="utf-8") as handle:
tree = ast.parse(handle.read(), path)
calls = [node for node in ast.walk(tree)
@@ -102,7 +105,7 @@ def extract_py(path):
def extract():
"""Liste ordonnee et sans doublon de (msgid, [fichiers sources])."""
"""Ordered list of unique (msgid, [source files])."""
found = {}
for name in SOURCES:
path = os.path.join(HERE, name)
@@ -115,7 +118,7 @@ def extract():
# --------------------------------------------------------------------------
# Lecture / ecriture des fichiers .po
# Reading / writing .po files
# --------------------------------------------------------------------------
_ESCAPES = {"n": "\n", "t": "\t", '"': '"', "\\": "\\"}
@@ -138,7 +141,7 @@ def _quote(text):
def read_po(path):
"""Dictionnaire msgid -> (msgstr, fuzzy). L'en-tete a pour cle ""."""
"""Dictionary msgid -> (msgstr, fuzzy). The header has the key ""."""
entries = {}
if not os.path.exists(path):
return entries
@@ -190,10 +193,10 @@ def _header(language):
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.",
title = ("Translation template" if language is None
else "Translation ({})".format(language))
out = ["# {} of the Inkscape extension \"{}\".".format(title, EXTENSION_NAME),
"# Generated by i18n.py; only edit the msgstr entries.",
"msgid \"\"",
"msgstr " + _quote(_header(language)),
""]
@@ -210,11 +213,11 @@ def write_po(path, language, messages, translations):
# --------------------------------------------------------------------------
# Compilation .mo (format GNU gettext)
# .mo compilation (GNU gettext format)
# --------------------------------------------------------------------------
def write_mo(path, catalog):
"""Ecrit un catalogue {msgid: msgstr} au format .mo, cles triees."""
"""Write a {msgid: msgstr} catalog in .mo format, keys sorted."""
keys = sorted(catalog)
ids = [key.encode("utf-8") for key in keys]
strs = [catalog[key].encode("utf-8") for key in keys]
@@ -244,7 +247,7 @@ def write_mo(path, catalog):
# --------------------------------------------------------------------------
# Commandes
# Commands
# --------------------------------------------------------------------------
def po_path(language):
@@ -259,7 +262,7 @@ 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))
print("{} strings -> po/{}.pot".format(len(messages), DOMAIN))
def cmd_update():
@@ -270,7 +273,7 @@ def cmd_update():
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)))
print("po/{}.po: {} to translate".format(language, len(missing)))
for msgid in missing:
print(" " + msgid.splitlines()[0])
@@ -282,7 +285,7 @@ def cmd_compile():
if msgid and msgstr and not fuzzy}
catalog[""] = _header(language)
write_mo(mo_path(language), catalog)
print("{} -> {} ({} chaines)".format(
print("{} -> {} ({} strings)".format(
os.path.relpath(po_path(language), HERE),
os.path.relpath(mo_path(language), HERE), len(catalog) - 1))
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env python3
# coding=utf-8
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""
Builds the zip to publish on inkscape.org (Extensions category).
python package.py # dist/dog_bandana-<version>.zip + .md5
python package.py --sign # also dist/dog_bandana-<version>.sig (GnuPG)
Follows https://inkscape.gitlab.io/extensions/documentation/authors/submit.html:
one zip for every platform, files at the root of the archive, nothing
downloaded at run time. numpy and lxml are shipped with Inkscape and are not
bundled. The version comes from dog_bandana_core.__version__.
Before writing the archive, checks that the shipped Python files parse with
the Python 3.8 grammar, and that the compiled translations and the dialog
image are present.
"""
import ast
import glob
import hashlib
import os
import re
import subprocess
import sys
import zipfile
HERE = os.path.dirname(os.path.abspath(__file__))
DIST = os.path.join(HERE, "dist")
NAME = "dog_bandana"
PYTHON_FILES = ["dog_bandana.py", "dog_bandana_core.py"]
FILES = ["dog_bandana.inx"] + PYTHON_FILES + [
"images/parameters_en.png", "LICENSE", "README.en.md"]
def version():
with open(os.path.join(HERE, "dog_bandana_core.py"), encoding="utf-8") as handle:
match = re.search(r'^__version__ = "([^"]+)"', handle.read(), re.M)
if not match:
sys.exit("__version__ not found in dog_bandana_core.py")
return match.group(1)
def shipped_files():
"""Relative paths of the files that go into the archive."""
locales = sorted(os.path.relpath(path, HERE).replace(os.sep, "/") for path in
glob.glob(os.path.join(HERE, "locale", "*", "LC_MESSAGES", "*.mo")))
if not locales:
sys.exit("No compiled translation: run python i18n.py first")
files = FILES + locales
missing = [name for name in files if not os.path.isfile(os.path.join(HERE, name))]
if missing:
sys.exit("Missing files: {}".format(", ".join(missing)))
return files
def check_python38():
"""The submission rules require Python 3.8 or later."""
for name in PYTHON_FILES:
with open(os.path.join(HERE, name), encoding="utf-8") as handle:
try:
ast.parse(handle.read(), name, feature_version=(3, 8))
except SyntaxError as error:
sys.exit("{} is not Python 3.8 compatible: {}".format(name, error))
def build():
check_python38()
files = shipped_files()
os.makedirs(DIST, exist_ok=True)
archive = os.path.join(DIST, "{}-{}.zip".format(NAME, version()))
with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as zipped:
for name in files:
zipped.write(os.path.join(HERE, name), name)
with open(archive, "rb") as handle:
digest = hashlib.md5(handle.read()).hexdigest()
with open(archive + ".md5", "w", encoding="ascii", newline="\n") as handle:
handle.write("{} {}\n".format(digest, os.path.basename(archive)))
print(archive)
for name in files:
print(" " + name)
print("md5 " + digest)
return archive
def sign(archive):
"""Detached GnuPG signature, with the key registered on inkscape.org."""
signature = os.path.splitext(archive)[0] + ".sig"
if os.path.exists(signature):
os.remove(signature)
subprocess.run(["gpg", "--output", signature, "--detach-sign", "--sign", archive],
check=True)
print(signature)
def main(argv):
archive = build()
if "--sign" in argv:
sign(archive)
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
+2 -2
View File
@@ -1,5 +1,5 @@
# Modele de traduction de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
# Translation template of the Inkscape extension "Dog Bandana Pattern Fill".
# Generated by i18n.py; only edit the msgstr entries.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
+2 -2
View File
@@ -1,5 +1,5 @@
# Traduction (en) de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
# Translation (en) of the Inkscape extension "Dog Bandana Pattern Fill".
# Generated by i18n.py; only edit the msgstr entries.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
+2 -2
View File
@@ -1,5 +1,5 @@
# Traduction (fr) de l'extension Inkscape « Dog Bandana Pattern Fill ».
# Genere par i18n.py ; ne modifier que les msgstr.
# Translation (fr) of the Inkscape extension "Dog Bandana Pattern Fill".
# Generated by i18n.py; only edit the msgstr entries.
msgid ""
msgstr ""
"Project-Id-Version: dogbandana\n"
+28 -26
View File
@@ -1,5 +1,7 @@
# coding=utf-8
"""Tests de l'extension « Dog Bandana » (pytest)."""
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2026 Alex
"""Tests of the "Dog Bandana Pattern Fill" extension (pytest)."""
import os
import re
@@ -23,7 +25,7 @@ SCALED = os.path.join(HERE, "tests", "data", "scaled.svg")
# --------------------------------------------------------------------------
# Noyau (sans inkex)
# Core (without inkex)
# --------------------------------------------------------------------------
def test_parse_color_inkscape_integer():
@@ -34,7 +36,7 @@ def test_parse_color_inkscape_integer():
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)
assert parse_color("not a color") == ("#b3b3b3", 1.0)
def test_polylines_to_d():
@@ -43,7 +45,7 @@ def test_polylines_to_d():
def covered_segments(polylines):
"""Segments (arrondis, sens indifferent) couverts par des polylignes."""
"""Segments (rounded, direction ignored) covered by polylines."""
out = []
for line in polylines:
for p, q in zip(line, line[1:]):
@@ -53,7 +55,7 @@ def covered_segments(polylines):
def test_chain_polylines_joins_touching_lines():
# Un « Y » (4 noeuds impairs : 2 traits au minimum) et un trait isole.
# A "Y" (4 odd nodes: at least 2 strokes) and an isolated stroke.
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)
@@ -83,7 +85,7 @@ def test_order_polylines_rotates_loops():
def test_laser_order_cuts_travel_on_a_grid():
# Quadrillage de segments unitaires dans un ordre defavorable.
# Grid of unit segments in an unfavourable order.
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]
@@ -93,7 +95,7 @@ def test_laser_order_cuts_travel_on_a_grid():
# --------------------------------------------------------------------------
# Motif de Turing : etapes
# Turing pattern: steps
# --------------------------------------------------------------------------
def test_rasterize_square_with_hole_even_odd():
@@ -105,10 +107,10 @@ def test_rasterize_square_with_hole_even_odd():
def test_rasterize_vertex_on_scanline_counted_once():
# Sommets de ce losange exactement sur les centres de lignes de pixels.
# Vertices of this diamond exactly on pixel row centers.
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
for row in mask: # each row: a single run
assert np.count_nonzero(np.diff(row.astype(int))) <= 2
@@ -126,14 +128,14 @@ def test_skeletonize_bar_to_single_line():
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.sum(axis=0).max() == 1 # one pixel per column
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
img[20, 5] = True # isolated dot
lines = trace_skeleton(img)
assert sorted(len(line) for line in lines) == [1, 10]
@@ -151,7 +153,7 @@ def test_trace_skeleton_line_cross_dot_and_loop():
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
img[8:10, 15] = True # 2-pixel spur
assert len(trace_skeleton(img)) == 3
assert len(trace_skeleton(img, min_spur=4)) == 2
@@ -174,7 +176,7 @@ def test_simplify_straight_line():
# --------------------------------------------------------------------------
# Motif de Turing : resultat
# Turing pattern: result
# --------------------------------------------------------------------------
RECT = [[(0, 0), (60, 0), (60, 40), (0, 40)]]
@@ -190,7 +192,7 @@ def test_pattern_stays_inside_with_margin(edge):
lines = turing_pattern(RECT, period, width, margin, seed=3, edge=edge)
assert lines
inset = margin + width / 2
tolerance = period / 8 # un pixel de calcul
tolerance = period / 8 # one computation pixel
for line in lines:
for x, y in line:
assert inset - tolerance <= x <= 60 - inset + tolerance
@@ -198,7 +200,7 @@ def test_pattern_stays_inside_with_margin(edge):
def test_pattern_density_matches_period():
"""Longueur des lignes ~ aire / periode : bandes espacees d'une periode."""
"""Line length ~ area / period: bands one period apart."""
period = 4.0
lines = turing_pattern(RECT, period, 2.0, seed=1)
total = sum(polyline_length(line) for line in lines)
@@ -230,7 +232,7 @@ def test_pattern_respects_holes():
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.
# Strip narrower than the stroke: nothing to draw.
assert turing_pattern([[(0, 0), (60, 0), (60, 1.5), (0, 1.5)]], 4.0, 2.0) == []
@@ -251,7 +253,7 @@ def test_laser_order_cuts_travel_on_pattern():
# --------------------------------------------------------------------------
# Bout en bout (necessite inkex)
# End to end (requires inkex)
# --------------------------------------------------------------------------
def run_extension(tmp_path, *args, source=SHAPES):
@@ -279,7 +281,7 @@ def test_end_to_end_group_and_holes(tmp_path):
(["--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.
# Unchanged document: inkex writes no output, only the message matters.
pytest.importorskip("inkex")
from dog_bandana import DogBandana
DogBandana().run(["--id=rect1", *args,
@@ -288,7 +290,7 @@ def test_end_to_end_errors(tmp_path, capsys, args, message):
def test_end_to_end_non_standard_document_scale(tmp_path):
"""Page de 400 mm pour 538,72 unites : svg.unittouu() s'y tromperait."""
"""400 mm page for 538.72 user units: svg.unittouu() would get it wrong."""
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)
@@ -305,27 +307,27 @@ def test_end_to_end_color(tmp_path):
# --------------------------------------------------------------------------
# Traductions
# Translations
# --------------------------------------------------------------------------
def test_translations_up_to_date_and_complete():
"""Chaque texte du .inx et des .py a sa traduction dans chaque catalogue."""
"""Every text of the .inx and .py files is translated in every catalog."""
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"
assert "mm" not in msgids # units marked 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)
assert not missing, "{}.po incomplete: {}".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)
"{}: .mo must be recompiled (python i18n.py)".format(language)
def test_po_roundtrip(tmp_path):
@@ -342,7 +344,7 @@ def test_po_roundtrip(tmp_path):
def test_inx_matches_arguments():
"""Chaque <param> du .inx a son add_argument, et inversement."""
"""Every <param> of the .inx has its add_argument, and vice versa."""
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"}
@@ -352,7 +354,7 @@ def test_inx_matches_arguments():
def test_inx_images_exist():
"""Les images de la boite de dialogue sont presentes (chemin relatif au .inx)."""
"""Dialog images exist (path relative to the .inx)."""
root = ET.parse(os.path.join(HERE, "dog_bandana.inx")).getroot()
for elem in root.iter():
if elem.tag.rsplit("}", 1)[-1] == "image":