Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016S8V7WxoS7YRoM34BVBkeo
174 lines
6.0 KiB
Python
174 lines
6.0 KiB
Python
# 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 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 mm_scale(svg):
|
|
"""Unites utilisateur par millimetre du document."""
|
|
return svg.unittouu("1mm")
|
|
|
|
|
|
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
|