212 lines
8.3 KiB
Python
212 lines
8.3 KiB
Python
#!/usr/bin/env python3
|
|
# coding=utf-8
|
|
"""
|
|
Extension Inkscape : remplit les formes selectionnees d'un motif de rubans ondules.
|
|
|
|
Le motif est un fond de traits verticaux sur lequel passent des rubans en S,
|
|
ranges en quinconce et alternativement inclines a droite et a gauche (effet de
|
|
tressage). Il est decoupe par le contour de chaque forme, trous compris.
|
|
|
|
La logique vit dans `wavy_ribbon_fill_core`, sans dependance a inkex.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
|
|
import inkex
|
|
from inkex import bezier
|
|
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 wavy_ribbon_fill_core.
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
from wavy_ribbon_fill_core import ( # noqa: E402
|
|
fill_polylines, parse_color, polylines_to_d, rings_bounds)
|
|
|
|
|
|
def use_system_language():
|
|
"""Renseigne LANGUAGE avec la langue du systeme si rien ne la fixe.
|
|
|
|
Sous Windows, Inkscape regle sur « langue du systeme » ne transmet aucune
|
|
variable de langue au script : gettext retomberait sur l'anglais alors que
|
|
la boite de dialogue, traduite par Inkscape lui-meme, est dans la langue
|
|
de l'utilisateur.
|
|
"""
|
|
if any(os.environ.get(name) for name in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG")):
|
|
return
|
|
try:
|
|
import ctypes
|
|
import locale
|
|
language = locale.windows_locale.get(
|
|
ctypes.windll.kernel32.GetUserDefaultUILanguage())
|
|
except Exception: # pylint: disable=broad-except
|
|
return # hors Windows : LANG est toujours defini
|
|
if language:
|
|
os.environ["LANGUAGE"] = language
|
|
|
|
|
|
# Installe _() dans les builtins : catalogue « wavyribbonfill » de la langue
|
|
# de l'interface (Inkscape transmet domaine et dossier par l'environnement),
|
|
# textes anglais d'origine sinon.
|
|
use_system_language()
|
|
localize()
|
|
|
|
|
|
def uu_per_mm(svg):
|
|
"""Unites utilisateur par millimetre, comme Inkscape les affiche.
|
|
|
|
svg.unittouu() devine l'unite du document par arrondi a l'unite connue la
|
|
plus proche : il se trompe des que l'echelle n'est pas standard (page
|
|
redimensionnee). On prend le rapport reel page / viewBox ; Inkscape
|
|
applique une echelle uniforme (preserveAspectRatio « meet »), soit la
|
|
plus petite des deux.
|
|
"""
|
|
try:
|
|
vb_w, vb_h = svg.viewbox_width, svg.viewbox_height
|
|
page_w = svg.to_dimensional(svg.viewport_width, "mm")
|
|
page_h = svg.to_dimensional(svg.viewport_height, "mm")
|
|
except AttributeError: # inkex anterieur a 1.2
|
|
return svg.unittouu("1mm")
|
|
if not (vb_w and vb_h and page_w and page_h):
|
|
return svg.unittouu("1mm")
|
|
return 1 / min(page_w / vb_w, page_h / vb_h)
|
|
|
|
|
|
def length_to_uu(svg, value, unit="mm"):
|
|
"""Longueur reelle (valeur + unite) -> unites utilisateur du document."""
|
|
return convert_unit("{}{}".format(value, unit), "mm") * uu_per_mm(svg)
|
|
|
|
# Au-dela, le calcul et le SVG produit deviennent trop lourds pour Inkscape.
|
|
MAX_LINES = 3000
|
|
|
|
|
|
class WavyRibbonFill(inkex.EffectExtension):
|
|
"""Pose un groupe « motif » au-dessus de chaque element selectionne."""
|
|
|
|
def add_arguments(self, pars):
|
|
# Un argument par <param> du .inx, memes noms et memes valeurs par defaut.
|
|
pars.add_argument("--tab", default="pattern")
|
|
pars.add_argument("--spacing", type=float, default=2.0)
|
|
pars.add_argument("--unit", default="mm")
|
|
pars.add_argument("--lines", type=int, default=5)
|
|
pars.add_argument("--shift", type=int, default=6)
|
|
pars.add_argument("--height", type=float, default=7.0)
|
|
pars.add_argument("--radius", type=float, default=2.8)
|
|
pars.add_argument("--stagger", type=float, default=1.0)
|
|
pars.add_argument("--columns", type=int, default=8)
|
|
pars.add_argument("--rows", type=float, default=7.75)
|
|
pars.add_argument("--angle", type=float, default=0.0)
|
|
pars.add_argument("--origin", default="shape")
|
|
pars.add_argument("--stroke_width", type=float, default=0.25)
|
|
pars.add_argument("--stroke_color", default="255")
|
|
pars.add_argument("--keep_original", type=inkex.Boolean, default=True)
|
|
|
|
def effect(self):
|
|
opt = self.options
|
|
|
|
elements = list(self.svg.selection.values())
|
|
if not elements:
|
|
inkex.errormsg(_("Select at least one shape."))
|
|
return
|
|
|
|
spacing = length_to_uu(self.svg, opt.spacing, opt.unit)
|
|
if spacing <= 0:
|
|
inkex.errormsg(_("The line spacing must be strictly positive."))
|
|
return
|
|
|
|
color, opacity = parse_color(opt.stroke_color, ("#000000", 1.0))
|
|
style = inkex.Style({
|
|
"fill": "none",
|
|
"stroke": color,
|
|
"stroke-opacity": str(opacity),
|
|
"stroke-width": str(length_to_uu(self.svg, opt.stroke_width, opt.unit)),
|
|
"stroke-linecap": "round",
|
|
"stroke-linejoin": "round",
|
|
})
|
|
|
|
for elem in elements:
|
|
self.process(elem, spacing, style)
|
|
|
|
def element_rings(self, elem, flatness):
|
|
"""Contours de l'element (ou des formes d'un groupe) en coordonnees
|
|
absolues du document, courbes aplaties."""
|
|
if isinstance(elem, inkex.Group):
|
|
shapes = [node for node in elem.descendants()
|
|
if isinstance(node, inkex.ShapeElement) and not isinstance(node, inkex.Group)]
|
|
else:
|
|
shapes = [elem]
|
|
rings = []
|
|
for shape in shapes:
|
|
if not isinstance(shape, inkex.ShapeElement) or isinstance(
|
|
shape, (inkex.TextElement, inkex.Image, inkex.Use)):
|
|
continue
|
|
path = shape.path.transform(shape.composed_transform())
|
|
superpath = path.to_superpath()
|
|
bezier.cspsubdiv(superpath, flatness)
|
|
for subpath in superpath:
|
|
ring = [(node[1][0], node[1][1]) for node in subpath]
|
|
if len(ring) >= 3:
|
|
rings.append(ring)
|
|
return rings
|
|
|
|
def process(self, elem, spacing, style):
|
|
"""Traite un element : calcul dans wavy_ribbon_fill_core, ecriture dans le SVG."""
|
|
opt = self.options
|
|
name = elem.label or elem.get_id()
|
|
|
|
rings = self.element_rings(elem, spacing / 20.0)
|
|
bounds = rings_bounds(rings)
|
|
if bounds is None:
|
|
inkex.errormsg(_("“{}” has no usable outline: select closed shapes or paths "
|
|
"(convert texts with Path > Object to Path).").format(name))
|
|
return
|
|
|
|
xmin, ymin, xmax, ymax = bounds
|
|
if max(xmax - xmin, ymax - ymin) / spacing > MAX_LINES:
|
|
inkex.errormsg(_("“{}” would need more than {} lines: increase the line "
|
|
"spacing.").format(name, MAX_LINES))
|
|
return
|
|
|
|
# Origine du motif : centre de la forme (motif centre), ou origine du
|
|
# document (motif continu d'une forme a l'autre).
|
|
origin = (0.0, 0.0)
|
|
if opt.origin == "shape":
|
|
origin = ((xmin + xmax) / 2.0, (ymin + ymax) / 2.0)
|
|
|
|
polylines = fill_polylines(
|
|
rings, spacing, lines=max(2, opt.lines), shift=max(1, opt.shift),
|
|
height=opt.height, radius=max(0.0, opt.radius), stagger=max(0.0, opt.stagger),
|
|
columns=max(1, opt.columns), rows=opt.rows, angle=opt.angle, origin=origin)
|
|
if not polylines:
|
|
inkex.errormsg(_("“{}” is too small for the pattern: reduce the line "
|
|
"spacing.").format(name))
|
|
return
|
|
|
|
parent = elem.getparent()
|
|
group = inkex.Group()
|
|
group.label = _("Wavy ribbon pattern")
|
|
if parent is not None:
|
|
# Motif calcule en coordonnees absolues du document : on
|
|
# neutralise la transformation heritee du parent d'accueil.
|
|
parent_transform = parent.composed_transform()
|
|
if parent_transform != inkex.Transform():
|
|
group.transform = -parent_transform
|
|
parent.insert(parent.index(elem) + 1, group)
|
|
else:
|
|
self.svg.add(group)
|
|
|
|
# Un seul chemin : une polyligne par sous-chemin.
|
|
node = inkex.PathElement()
|
|
node.set("d", polylines_to_d(polylines))
|
|
node.style = style
|
|
group.add(node)
|
|
|
|
if not opt.keep_original:
|
|
elem.delete()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
WavyRibbonFill().run()
|