225 lines
8.9 KiB
Python
225 lines
8.9 KiB
Python
#!/usr/bin/env python3
|
|
# coding=utf-8
|
|
"""
|
|
Extension Inkscape : remplit les formes selectionnees de tetes de mort,
|
|
pretes pour la gravure laser.
|
|
|
|
Comme dans le motif de reference (doc/patern.png), un meme crane (dessine
|
|
d'apres doc/dessin.svg, sans ses cornes) est repete a des tailles, des
|
|
angles et en miroir differents, sans laisser de vide : les petits dessous,
|
|
les grands par-dessus.
|
|
|
|
Une decoupeuse laser grave tout trait present dans le fichier, meme cache
|
|
ou masque. Le resultat ne contient donc que l'encre reellement visible :
|
|
pour chaque crane, son trait moins ce que couvrent les cranes du dessus,
|
|
limite a la forme ; plus, en option, les interstices entre les cranes.
|
|
Aucun masque, aucun clone, aucun objet blanc.
|
|
|
|
La logique vit dans `skull_fill_core` (et `boolean_ops`), sans inkex.
|
|
"""
|
|
|
|
import math
|
|
import os
|
|
import sys
|
|
|
|
import inkex
|
|
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 skull_fill_core.
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
from skull_fill_core import ( # noqa: E402
|
|
Region, estimate_count, parse_color, rings_to_d, skull_placements,
|
|
visible_gaps, visible_skulls)
|
|
|
|
# Au-dela, le calcul (environ 5 s pour 100 cranes) devient trop long.
|
|
MAX_SKULLS = 10000
|
|
|
|
|
|
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 « skullfill » 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)
|
|
|
|
|
|
class SkullFill(inkex.EffectExtension):
|
|
"""Remplit chaque forme selectionnee de tetes de mort (encre visible seule)."""
|
|
|
|
def add_arguments(self, pars):
|
|
# Un argument par <param> du .inx, memes noms et memes valeurs par defaut.
|
|
pars.add_argument("--tab", default="skulls")
|
|
pars.add_argument("--size_max", type=float, default=30.0)
|
|
pars.add_argument("--size_min", type=float, default=10.0)
|
|
pars.add_argument("--unit", default="mm")
|
|
pars.add_argument("--spacing", type=float, default=70.0)
|
|
pars.add_argument("--max_rotation", type=float, default=30.0)
|
|
pars.add_argument("--mirror", type=inkex.Boolean, default=True)
|
|
pars.add_argument("--seed", type=int, default=1)
|
|
pars.add_argument("--ink_color", default="255")
|
|
pars.add_argument("--fill_gaps", type=inkex.Boolean, default=True)
|
|
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 to fill."))
|
|
return
|
|
|
|
shapes = []
|
|
for elem in elements:
|
|
shapes.extend(self.fillable(elem))
|
|
if not shapes:
|
|
inkex.errormsg(_("No fillable shape in the selection: select paths, "
|
|
"rectangles, circles, ellipses or groups of them."))
|
|
return
|
|
|
|
size_min = length_to_uu(self.svg, opt.size_min, opt.unit)
|
|
size_max = length_to_uu(self.svg, opt.size_max, opt.unit)
|
|
if size_min <= 0 or size_max <= 0:
|
|
inkex.errormsg(_("The skull sizes must be strictly positive."))
|
|
return
|
|
if size_max < size_min:
|
|
size_min, size_max = size_max, size_min
|
|
|
|
self.ink = parse_color(opt.ink_color, ("#000000", 1.0))
|
|
|
|
regions = [(elem, self.rings(elem)) for elem in shapes]
|
|
spacing = opt.spacing / 100.0
|
|
total = sum(estimate_count(rings, size_min, spacing) for _elem, rings in regions)
|
|
if total > MAX_SKULLS:
|
|
inkex.errormsg(_("About {} skulls would be needed. Increase the minimum "
|
|
"size or the spacing.").format(total))
|
|
return
|
|
|
|
# Coordonnees au 1/500 de la plus petite hauteur : bien sous la
|
|
# finesse d'un laser, sans alourdir le fichier.
|
|
self.precision = max(0, int(math.ceil(-math.log10(size_min / 500.0))))
|
|
|
|
for elem, rings in regions:
|
|
placements = skull_placements(
|
|
rings, size_min, size_max, spacing=spacing,
|
|
max_rotation=opt.max_rotation, mirror=opt.mirror, seed=opt.seed)
|
|
self.process(elem, Region(rings), placements)
|
|
|
|
@staticmethod
|
|
def fillable(elem):
|
|
"""Formes a remplir : l'element lui-meme, ou les formes d'un groupe."""
|
|
if isinstance(elem, inkex.Group):
|
|
return [child for child in elem.descendants()
|
|
if isinstance(child, inkex.ShapeElement)
|
|
and not isinstance(child, (inkex.Group, inkex.TextElement))
|
|
and child.get_path() is not None]
|
|
if isinstance(elem, (inkex.TextElement, inkex.Image)) or \
|
|
not isinstance(elem, inkex.ShapeElement):
|
|
return []
|
|
return [elem]
|
|
|
|
@staticmethod
|
|
def absolute_path(elem):
|
|
return elem.path.transform(elem.composed_transform())
|
|
|
|
def rings(self, elem):
|
|
"""Contour de la forme en coordonnees absolues, courbes aplaties."""
|
|
csp = self.absolute_path(elem).to_superpath()
|
|
inkex.bezier.cspsubdiv(csp, 0.1)
|
|
return [[(point[1][0], point[1][1]) for point in sub] for sub in csp if len(sub) > 2]
|
|
|
|
def ink_path(self, rings, label=None):
|
|
"""Chemin rempli de la couleur de l'encre, en regle pair-impair."""
|
|
color, opacity = self.ink
|
|
path = inkex.PathElement()
|
|
path.set("d", rings_to_d(rings, self.precision))
|
|
path.style = inkex.Style({
|
|
"fill": color, "fill-opacity": str(opacity),
|
|
"fill-rule": "evenodd", "stroke": "none"})
|
|
if label:
|
|
path.label = label
|
|
return path
|
|
|
|
def process(self, elem, region, placements):
|
|
"""Ecrit le remplissage d'une forme, juste au-dessus d'elle."""
|
|
opt = self.options
|
|
parent = elem.getparent()
|
|
group = inkex.Group()
|
|
group.label = _("Skull fill")
|
|
if parent is not None:
|
|
# Resultat calcule en coordonnees absolues du document : on
|
|
# neutralise la transformation heritee du parent d'accueil.
|
|
parent_transform = parent.composed_transform()
|
|
if parent_transform != inkex.Transform():
|
|
group.transform = -parent_transform
|
|
parent.insert(parent.index(elem) + 1, group)
|
|
else:
|
|
self.svg.add(group)
|
|
|
|
if opt.fill_gaps:
|
|
# Interstices : la forme moins toutes les silhouettes, comme les
|
|
# ombres entre les cranes du motif de reference.
|
|
gaps = visible_gaps(placements, region)
|
|
if gaps:
|
|
group.add(self.ink_path(gaps, _("Gaps")))
|
|
|
|
# Un chemin par crane visible : son trait, moins ce que cachent les
|
|
# cranes du dessus, limite a la forme. Les chemins ne se recouvrent
|
|
# pas : le laser ne grave rien de cache.
|
|
for _placement, rings in visible_skulls(placements, region):
|
|
group.add(self.ink_path(rings))
|
|
|
|
if not opt.keep_original:
|
|
elem.delete()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
SkullFill().run()
|