# coding=utf-8 """ Outils inkex partages par les entrees de menu « Board photo ». Page a la taille de la zone de travail, calques reperes par un attribut `data-board-photo`. Les textes affiches restent dans les scripts (appels _() extraits par i18n.py). """ import os import re import inkex DATA = "data-board-photo" # attribut qui marque nos calques et chemins OUTLINE_SHAPE = "outline-path" # valeur portee par le chemin du contour # Sur le calque de la photo : zone de travail (mm) utilisee pour la calibrer, « l h ». AREA_ATTR = "data-board-photo-area" # Enfants de la racine qui ne sont pas du dessin : on insere les calques # du fond juste apres eux. _NOT_DRAWING = {"defs", "namedview", "metadata", "title", "desc", "style", "script"} 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 def mm_scale(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_uu(svg, value, default=0.0): """Attribut de longueur d'un element en unites utilisateur. Sans unite, la valeur est deja en unites utilisateur ; `unittouu` la prendrait pour des px et la convertirait a tort. """ text = str(value if value is not None else "").strip() if not text: return default if re.match(r"^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$", text): return float(text) return svg.unittouu(text) def prepare_page(svg, width, height, set_page=True): """Page de `width` x `height` mm ; renvoie (uu par mm, origine x, origine y). L'echelle utilisateur existante est conservee (le viewBox suit la nouvelle taille) : les objets deja presents gardent leurs dimensions. """ scale = mm_scale(svg) box = svg.get("viewBox") ox = oy = 0.0 if box: values = [float(v) for v in box.replace(",", " ").split()] if len(values) == 4: ox, oy = values[0], values[1] if set_page: svg.set("width", "{}mm".format(fmt(width))) svg.set("height", "{}mm".format(fmt(height))) svg.set("viewBox", "{} {} {} {}".format( fmt(ox), fmt(oy), fmt(width * scale), fmt(height * scale))) pages = svg.namedview.findall(inkex.addNS("page", "inkscape")) if len(pages) == 1: pages[0].set("width", fmt(width * scale)) pages[0].set("height", fmt(height * scale)) return scale, ox, oy def fmt(value): return "{:.6f}".format(value).rstrip("0").rstrip(".") # Couleur des viseurs, portee par leur calque (voir `paint_layer`). TARGET_COLOR = "#ff0000" def paint_layer(layer, fill="none", stroke="none"): """Donne au calque les couleurs de remplissage et de contour de ses formes. L'extension « Export to LaserGRBL » grave ou decoupe chaque chemin selon les couleurs `fill` / `stroke` de son propre attribut style, sans tenir compte des calques masques : nos formes d'aide (contour de la planche, viseurs, rapport) ne portent donc aucune couleur a elles et heritent celles de leur calque. Affichees a l'identique, jamais exportees. """ layer.style = inkex.Style({"fill": fill, "stroke": stroke}) return layer def target(cx, cy, radius, scale, label): """Viseur (croix dans un cercle) centre en (cx, cy), unites utilisateur. Sans couleur propre : le poser dans un calque colore par `paint_layer`. """ path = inkex.PathElement() path.set("d", ("M {x0},{cy} L {x1},{cy} M {cx},{y0} L {cx},{y1} " "M {x1},{cy} A {r},{r} 0 1 1 {x0},{cy} " "A {r},{r} 0 1 1 {x1},{cy} Z").format( x0=fmt(cx - radius), x1=fmt(cx + radius), y0=fmt(cy - radius), y1=fmt(cy + radius), cx=fmt(cx), cy=fmt(cy), r=fmt(radius))) path.style = inkex.Style({"stroke-width": str(0.4 * scale)}) path.label = label return path def center_of(elem): """Centre de la boite englobante d'un element, en coordonnees du document.""" return elem.bounding_box(elem.getparent().composed_transform()).center def find_all(svg, key): """Elements dont l'attribut data-board-photo vaut `key`.""" return svg.xpath("//*[@{}='{}']".format(DATA, key)) def remove_layers(svg, key): for elem in find_all(svg, key): elem.delete() def new_layer(label, key, locked=False): layer = inkex.Layer.new(label) layer.set(DATA, key) if locked: layer.set("sodipodi:insensitive", "true") return layer def insert_bottom(svg, layer): """Place un calque sous tout le dessin existant.""" index = 0 for index, child in enumerate(svg): tag = child.TAG if hasattr(child, "TAG") else "" local = str(child.tag).rsplit("}", 1)[-1] if local not in _NOT_DRAWING and tag not in _NOT_DRAWING: break else: index = len(svg) svg.insert(index, layer) def set_current_layer(svg, layer): """Calque actif a l'ouverture : l'utilisateur dessine directement dedans.""" svg.namedview.set(inkex.addNS("current-layer", "inkscape"), layer.get_id()) # -------------------------------------------------------------------------- # « Export to LaserGRBL » : origine du G-code au coin bas gauche de la page # (viewBox), le remplissage ignorant l'abscisse du viewBox ; la page doit donc # etre la zone de travail et commencer en 0 0. # -------------------------------------------------------------------------- def page_problems(svg): """Defauts de la page qui decaleraient le G-code. `viewbox_offset` : viewBox ne commencant pas en 0 0 (le remplissage de l'export ignore ce decalage) ; `page_size` : page differente de la zone de travail de la photo calibree (l'origine du G-code est le bas gauche de la page). """ problems = [] box = svg.get_viewbox() if abs(box[0]) > 1e-6 or abs(box[1]) > 1e-6: problems.append("viewbox_offset") photos = find_all(svg, "photo") area = photos[0].get(AREA_ATTR) if photos else None if area: width, height = (float(v) for v in area.split()) page_w = svg.unit_to_viewport(box[2], "mm") page_h = svg.unit_to_viewport(box[3], "mm") if abs(page_w - width) > 0.01 or abs(page_h - height) > 0.01: problems.append("page_size") return problems