#!/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 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()