Linter for inkscape extension
This commit is contained in:
1 parent
00e9ba3434
commit
247ecc3f5a
17 files changed
+1002
-249
No files matched your search
@@ -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/
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
@@ -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
@@ -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",
|
||||
|
||||
@@ -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
@@ -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!
|
||||
```
|
||||
@@ -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.
|
||||
|
||||

|
||||
|
||||
## 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
|
||||
@@ -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
@@ -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
@@ -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
@@ -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 []
|
||||
|
||||
@@ -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
@@ -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
@@ -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"
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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
@@ -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":
|
||||
|
||||
Reference in new issue
Block a user