Files
inkscape.calibrationDecoupe…/board_photo_common.py
T
2026-09-25 17:14:49 +02:00

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