Files

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()