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

540 lines
21 KiB
Python

# coding=utf-8
"""
Noyau geometrique de l'extension « Board photo », sans dependance a inkex.
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
des parametres). Seule dependance : numpy, fourni avec Inkscape 1.x.
Conventions :
- toutes les longueurs sont en millimetres ;
- repere SVG : origine en haut a gauche de la zone de travail, y vers le bas ;
- repere laser : origine en bas a gauche de la zone de travail, y vers le haut
(conversion par `laser_to_svg` / `svg_to_laser`, seul endroit ou l'on
retourne l'axe y) ;
- coordonnees image « continues » : le pixel (ligne r, colonne c) couvre le
carre [c, c+1] x [r, r+1], son centre est donc en (c + 0.5, r + 0.5) ;
- un contour (`rings`) est une liste d'anneaux, chaque anneau etant une liste
de points (x, y) fermee implicitement ; les trous suivent la regle pair-impair ;
- les 4 reperes de calibration sont toujours ranges dans l'ordre
haut-gauche, haut-droite, bas-droite, bas-gauche (repere SVG) ; le repere
« origine » (deux pastilles) est celui du bas-gauche, a l'origine laser.
"""
import math
import numpy as np
# Indices des reperes dans l'ordre standard.
TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT = range(4)
ORIGIN_MARKER = BOTTOM_LEFT
# Geometrie d'un repere, en fraction du cote du carre.
DOT_DIAMETER = 0.30 # pastille unique des reperes ordinaires
ORIGIN_DOT_DIAMETER = 0.25 # deux pastilles du repere origine
ORIGIN_DOT_OFFSET = 0.18 # decalage de chaque pastille sur la diagonale
def parse_color(value, default=("#b3b3b3", 1.0)):
"""Couleur Inkscape (entier RGBA decimal ou 0x..., ou #rrggbb[aa]).
Renvoie (couleur CSS #rrggbb, opacite entre 0 et 1). Le parametre
« color » d'Inkscape arrive sous forme d'entier RGBA ; on le decode
nous-memes pour ne pas dependre de l'API couleur d'inkex, qui a change
entre les versions 1.x.
"""
text = str(value).strip()
try:
if text.startswith("#"):
digits = text[1:]
if len(digits) == 3:
digits = "".join(c * 2 for c in digits)
if len(digits) == 6:
digits += "ff"
if len(digits) != 8:
return default
number = int(digits, 16)
else:
number = int(text, 0)
except ValueError:
return default
number &= 0xFFFFFFFF
red, green, blue = (number >> 24) & 255, (number >> 16) & 255, (number >> 8) & 255
alpha = (number & 255) / 255.0
return "#{:02x}{:02x}{:02x}".format(red, green, blue), round(alpha, 4)
def polylines_to_d(polylines, precision=4, closed=False):
"""Donnees `d` d'un chemin SVG : une polyligne par sous-chemin."""
fmt = "{:.%df},{:.%df}" % (precision, precision)
parts = []
for polyline in polylines:
if len(polyline) < 2:
continue
parts.append("M " + fmt.format(*polyline[0]))
parts.extend("L " + fmt.format(*point) for point in polyline[1:])
if closed:
parts.append("Z")
return " ".join(parts)
# --------------------------------------------------------------------------
# Reperes laser / SVG et disposition des reperes de calibration
# --------------------------------------------------------------------------
def laser_to_svg(point, height):
"""Point du repere laser (y vers le haut) -> repere SVG (y vers le bas)."""
return float(point[0]), float(height) - float(point[1])
def svg_to_laser(point, height):
"""Point du repere SVG -> repere laser ; la conversion est son propre inverse."""
return laser_to_svg(point, height)
def marker_layout(height, origin_x, origin_y, spacing_x, spacing_y):
"""Centres des 4 reperes en repere SVG, ordre HG, HD, BD, BG.
(origin_x, origin_y) est le centre du repere origine en repere laser,
(spacing_x, spacing_y) l'ecart entre centres de reperes.
"""
laser = [(origin_x, origin_y + spacing_y),
(origin_x + spacing_x, origin_y + spacing_y),
(origin_x + spacing_x, origin_y),
(origin_x, origin_y)]
return [laser_to_svg(p, height) for p in laser]
PHOTO_MARGIN = 1.5 # marge autour des reperes, en tailles de repere
def photo_extent(width, height, origin_x, origin_y, spacing_x, spacing_y, size,
resolution):
"""Rectangle (x0, y0, x1, y1) en mm, repere SVG, couvert par la photo redressee.
La zone de travail, agrandie pour montrer les reperes en entier (avec leur
zone claire) quand ils sont colles autour. Bornes alignees sur la grille
des pixels (multiples de 1 / resolution) : la zone de travail tombe sur
des pixels entiers de l'image.
"""
centers = marker_layout(height, origin_x, origin_y, spacing_x, spacing_y)
reach = PHOTO_MARGIN * size
xs = [c[0] for c in centers]
ys = [c[1] for c in centers]
x0, x1 = min(0.0, min(xs) - reach), max(float(width), max(xs) + reach)
y0, y1 = min(0.0, min(ys) - reach), max(float(height), max(ys) + reach)
res = float(resolution)
return (math.floor(x0 * res + 1e-9) / res, math.floor(y0 * res + 1e-9) / res,
math.ceil(x1 * res - 1e-9) / res, math.ceil(y1 * res - 1e-9) / res)
def layout_problems(width, height, origin_x, origin_y, spacing_x, spacing_y, size,
reach=None):
"""Liste des defauts de disposition (vide si les reperes tiennent dans la zone).
`reach` : demi-emprise autour de chaque centre qui doit tenir dans la zone
(par defaut le demi-cote du repere ; `guide_reach` pour les gabarits).
"""
problems = []
if min(width, height, spacing_x, spacing_y, size) <= 0:
problems.append("non_positive")
return problems
half = size / 2.0 if reach is None else reach
if (origin_x - half < 0 or origin_y - half < 0
or origin_x + spacing_x + half > width
or origin_y + spacing_y + half > height):
problems.append("outside")
if spacing_x < 2 * size or spacing_y < 2 * size:
problems.append("too_close")
return problems
def circle_ring(center, radius, segments=72):
"""Polygone regulier approchant un cercle (sens trigonometrique ecran)."""
cx, cy = center
return [(cx + radius * math.cos(2 * math.pi * k / segments),
cy + radius * math.sin(2 * math.pi * k / segments))
for k in range(segments)]
def marker_rings(center, size, origin=False):
"""Anneaux d'un repere : carre plein + pastille(s) claire(s) (pair-impair).
Le repere ordinaire porte une pastille centrale ; le repere origine en
porte deux sur la diagonale, ce qui permet de retrouver l'orientation
de la photo.
"""
cx, cy = center
half = size / 2.0
square = [(cx - half, cy - half), (cx + half, cy - half),
(cx + half, cy + half), (cx - half, cy + half)]
if origin:
radius = ORIGIN_DOT_DIAMETER * size / 2.0
offset = ORIGIN_DOT_OFFSET * size
dots = [circle_ring((cx - offset, cy - offset), radius),
circle_ring((cx + offset, cy + offset), radius)]
else:
dots = [circle_ring((cx, cy), DOT_DIAMETER * size / 2.0)]
return [square] + dots
# --------------------------------------------------------------------------
# Reperes imprimes : feuille A4 a decouper et gabarits de pose
# --------------------------------------------------------------------------
A4 = (210.0, 297.0)
PIECE_FACTOR = 2.0 # cote d'une piece decoupee / cote du repere (zone claire)
TICK_LENGTH = 0.15 # longueur des traits d'alignement, en fraction du repere
def piece_side(size):
"""Cote de la piece de papier a decouper autour d'un repere."""
return PIECE_FACTOR * size
def sheet_layout(size, page=A4, margin=12.0, header=38.0, footer=22.0, gap=14.0):
"""Centres des 4 pieces sur une feuille, ordre HG, HD, BD, BG ; None si trop grand.
Grille 2 x 2 si elle tient (meme disposition que sur la surface : le
repere origine en bas a gauche), sinon une colonne. `gap` separe les
pieces et laisse la place d'une legende sous chacune.
"""
side = piece_side(size)
width = page[0] - 2 * margin
height = page[1] - 2 * margin - header - footer
if size <= 0:
return None
for columns in (2, 1):
rows = 4 // columns
grid_w = columns * side + (columns - 1) * gap
grid_h = rows * side + rows * gap
if grid_w <= width and grid_h <= height:
break
else:
return None
x0 = (page[0] - grid_w) / 2.0 + side / 2.0
y0 = margin + header + side / 2.0
pitch = side + gap
if columns == 2:
cells = [(0, 0), (1, 0), (1, 1), (0, 1)]
else:
cells = [(0, 0), (0, 1), (0, 2), (0, 3)]
return [(x0 + c * pitch, y0 + r * pitch) for c, r in cells]
def corner_layout(width, height, size):
"""Reperes colles autour de la zone de travail, le coin interieur de chaque
piece de papier touchant un angle de la zone (nid d'abeille).
Le centre de chaque repere est a une demi-piece (= taille du repere) de
l'angle, en X et en Y. Renvoie (origin_x, origin_y, spacing_x, spacing_y),
en mm, repere laser (origine a l'angle bas gauche de la zone).
"""
half = piece_side(size) / 2.0
return -half, -half, float(width) + 2 * half, float(height) + 2 * half
def piece_ticks(center, size):
"""Traits d'alignement au milieu de chaque bord de la piece, vers le centre.
Ils se posent sur la croix du gabarit grave : le centre du repere tombe
alors exactement sur la position attendue.
"""
cx, cy = center
half = piece_side(size) / 2.0
inner = half - TICK_LENGTH * size
return [[(cx - half, cy), (cx - inner, cy)], [(cx + inner, cy), (cx + half, cy)],
[(cx, cy - half), (cx, cy - inner)], [(cx, cy + inner), (cx, cy + half)]]
def piece_outline(center, size):
"""Contour ferme de la piece (ligne de decoupe, ou gabarit de pose)."""
cx, cy = center
half = piece_side(size) / 2.0
ring = [(cx - half, cy - half), (cx + half, cy - half),
(cx + half, cy + half), (cx - half, cy + half)]
return ring + [ring[0]]
def guide_reach(size):
"""Demi-emprise d'un gabarit de pose : piece + croix qui depasse de size / 2."""
return piece_side(size) / 2.0 + size / 2.0
def guide_lines(center, size, overshoot=None):
"""Gabarit de pose : contour de la piece et croix qui depasse de chaque cote."""
cx, cy = center
half = piece_side(size) / 2.0
reach = half + (size / 2.0 if overshoot is None else overshoot)
return [piece_outline(center, size),
[(cx - reach, cy), (cx - half, cy)], [(cx + half, cy), (cx + reach, cy)],
[(cx, cy - reach), (cx, cy - half)], [(cx, cy + half), (cx, cy + reach)]]
def scale_bar(start, length=100.0, step=10.0, tick=3.0, vertical=False):
"""Barre de controle d'impression : trait de `length` mm gradue tous les `step`.
Horizontale, graduations vers le haut ; verticale (vers le bas depuis
`start`), graduations vers la gauche.
"""
x0, y0 = start
count = int(round(length / step))
if vertical:
lines = [[(x0, y0), (x0, y0 + length)]]
else:
lines = [[(x0, y0), (x0 + length, y0)]]
for k in range(count + 1):
h = tick * (1.6 if k in (0, count) else 1.0)
if vertical:
y = y0 + k * step
lines.append([(x0, y), (x0 - h, y)])
else:
x = x0 + k * step
lines.append([(x, y0), (x, y0 - h)])
return lines
def print_correction(measured_x, measured_y, nominal=100.0):
"""Facteurs d'agrandissement qui compensent une imprimante qui reduit.
Une barre de `nominal` mm mesuree `measured` mm apres impression : on
dessine `nominal / measured` fois plus grand pour qu'elle ressorte juste.
"""
return nominal / float(measured_x), nominal / float(measured_y)
def stretch_rings(rings, fx, fy, center):
"""Etire les anneaux de (fx, fy) autour de `center`."""
cx, cy = center
return [[(cx + (x - cx) * fx, cy + (y - cy) * fy) for x, y in ring] for ring in rings]
# --------------------------------------------------------------------------
# Homographie (projection plane) a partir de 4 correspondances
# --------------------------------------------------------------------------
def _normalizer(points):
"""Similitude qui centre les points et ramene leur distance moyenne a sqrt(2).
Normalisation de Hartley : rend la resolution numerique stable quel que
soit l'ordre de grandeur des coordonnees (pixels contre millimetres).
"""
pts = np.asarray(points, dtype=float)
center = pts.mean(axis=0)
spread = np.sqrt(((pts - center) ** 2).sum(axis=1)).mean()
scale = math.sqrt(2) / spread if spread > 0 else 1.0
return np.array([[scale, 0, -scale * center[0]],
[0, scale, -scale * center[1]],
[0, 0, 1]])
def homography(src, dst):
"""Matrice 3x3 qui envoie exactement 4 points `src` sur 4 points `dst`.
Leve ValueError si la configuration est degeneree (3 points alignes).
"""
src = np.asarray(src, dtype=float)
dst = np.asarray(dst, dtype=float)
if src.shape != (4, 2) or dst.shape != (4, 2):
raise ValueError("4 points attendus")
ts, td = _normalizer(src), _normalizer(dst)
s = apply_homography(ts, src)
d = apply_homography(td, dst)
rows, rhs = [], []
for (x, y), (u, v) in zip(s, d):
rows.append([x, y, 1, 0, 0, 0, -u * x, -u * y])
rows.append([0, 0, 0, x, y, 1, -v * x, -v * y])
rhs += [u, v]
a = np.array(rows)
if abs(np.linalg.det(a)) < 1e-12:
raise ValueError("points degeneres")
h = np.append(np.linalg.solve(a, np.array(rhs)), 1.0).reshape(3, 3)
matrix = np.linalg.inv(td) @ h @ ts
return matrix / matrix[2, 2]
def apply_homography(matrix, points):
"""Applique une homographie a une liste de points (renvoie un tableau Nx2)."""
pts = np.asarray(points, dtype=float).reshape(-1, 2)
homog = np.hstack([pts, np.ones((len(pts), 1))]) @ np.asarray(matrix).T
return homog[:, :2] / homog[:, 2:3]
def local_scale(matrix, point):
"""Facteur d'echelle local (moyenne geometrique) de l'homographie en un point."""
x, y = point
eps = 1.0
p = apply_homography(matrix, [(x, y), (x + eps, y), (x, y + eps)])
jac = np.array([p[1] - p[0], p[2] - p[0]]) / eps
return math.sqrt(abs(np.linalg.det(jac)))
def is_convex_quad(points):
"""Vrai si les 4 points (dans l'ordre) forment un quadrilatere convexe."""
pts = np.asarray(points, dtype=float)
signs = []
for k in range(4):
a, b, c = pts[k], pts[(k + 1) % 4], pts[(k + 2) % 4]
cross = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
signs.append(cross)
return all(s > 0 for s in signs) or all(s < 0 for s in signs)
def order_corners(points):
"""Range 4 points (repere image, y vers le bas) en HG, HD, BD, BG.
Tri par angle autour du barycentre : robuste a une rotation de la
photo jusqu'a 45 degres ; au-dela, c'est le repere origine qui
retablit l'orientation (`rotate_to_origin`).
"""
pts = [tuple(map(float, p)) for p in points]
cx = sum(p[0] for p in pts) / 4.0
cy = sum(p[1] for p in pts) / 4.0
# atan2 en y vers le bas : HG ~ -135 deg, HD ~ -45, BD ~ 45, BG ~ 135.
return sorted(pts, key=lambda p: math.atan2(p[1] - cy, p[0] - cx))
def rotate_to_origin(ordered, origin_index):
"""Decale cycliquement 4 points ordonnes pour que `origin_index` passe en BG."""
shift = (origin_index - ORIGIN_MARKER) % 4
return [ordered[(k + shift) % 4] for k in range(4)]
# --------------------------------------------------------------------------
# Contours d'un masque binaire
# --------------------------------------------------------------------------
# Rotation d'un quart de tour dans le sens horaire a l'ecran (y vers le bas).
def _turn_right(direction):
dx, dy = direction
return -dy, dx
def mask_to_rings(mask):
"""Contours d'un masque binaire (tableau 2D) en coordonnees image continues.
Suit les aretes entre pixels allumes et eteints (le premier plan reste a
droite du sens de parcours), puis prend le milieu de chaque arete : on
obtient un contour qui suit la frontiere a mieux que le demi-pixel, sans
marches d'escalier. Aux sommets en « damier », on tourne a droite, ce qui
separe deux pixels qui ne se touchent que par un coin.
"""
m = np.pad(np.asarray(mask, dtype=bool), 1)
edges = {}
def add(rows, cols, start, direction):
for r, c in zip(rows.tolist(), cols.tolist()):
# (r, c) indices dans le masque borde : pixel d'origine (r-1, c-1).
x0, y0 = c - 1 + start[0], r - 1 + start[1]
edges.setdefault((x0, y0), []).append(direction)
inner = m[1:-1, 1:-1]
# Arete du haut, parcourue vers la droite ; bas vers la gauche ;
# droite vers le bas ; gauche vers le haut (sens horaire a l'ecran).
r, c = np.nonzero(inner & ~m[:-2, 1:-1])
add(r + 1, c + 1, (0, 0), (1, 0))
r, c = np.nonzero(inner & ~m[2:, 1:-1])
add(r + 1, c + 1, (1, 1), (-1, 0))
r, c = np.nonzero(inner & ~m[1:-1, 2:])
add(r + 1, c + 1, (1, 0), (0, 1))
r, c = np.nonzero(inner & ~m[1:-1, :-2])
add(r + 1, c + 1, (0, 1), (0, -1))
rings = []
while edges:
start = next(iter(edges))
direction = edges[start][0]
vertex = start
ring = []
while True:
outgoing = edges.get(vertex)
if not outgoing or (ring and vertex == start):
break
if len(outgoing) == 1:
chosen = outgoing[0]
else:
# Sommet en damier : on tourne a droite.
right = _turn_right(direction)
chosen = right if right in outgoing else outgoing[0]
outgoing.remove(chosen)
if not outgoing:
del edges[vertex]
ring.append((vertex[0] + chosen[0] / 2.0, vertex[1] + chosen[1] / 2.0))
vertex = (vertex[0] + chosen[0], vertex[1] + chosen[1])
direction = chosen
if len(ring) >= 3:
rings.append(ring)
return rings
def _dp(points, tolerance):
"""Douglas-Peucker iteratif sur une polyligne ouverte (extremites gardees)."""
pts = np.asarray(points, dtype=float)
keep = np.zeros(len(pts), dtype=bool)
keep[0] = keep[-1] = True
stack = [(0, len(pts) - 1)]
while stack:
first, last = stack.pop()
if last - first < 2:
continue
a, b = pts[first], pts[last]
seg = pts[first + 1:last]
ab = b - a
norm = math.hypot(ab[0], ab[1])
if norm == 0:
dist = np.hypot(seg[:, 0] - a[0], seg[:, 1] - a[1])
else:
dist = np.abs(ab[0] * (seg[:, 1] - a[1]) - ab[1] * (seg[:, 0] - a[0])) / norm
index = int(np.argmax(dist))
if dist[index] > tolerance:
split = first + 1 + index
keep[split] = True
stack.append((first, split))
stack.append((split, last))
return [tuple(p) for p in pts[keep]]
def simplify_ring(ring, tolerance):
"""Simplifie un anneau ferme (Douglas-Peucker) ; renvoie au moins 3 points."""
if tolerance <= 0 or len(ring) <= 4:
return list(ring)
pts = np.asarray(ring, dtype=float)
# Coupe l'anneau entre deux points eloignes pour simplifier deux moities.
far = int(np.argmax(np.hypot(pts[:, 0] - pts[0, 0], pts[:, 1] - pts[0, 1])))
if far == 0:
return list(ring)
first = _dp(list(pts[:far + 1]), tolerance)
second = _dp(list(pts[far:]) + [tuple(pts[0])], tolerance)
result = first[:-1] + second[:-1]
return result if len(result) >= 3 else list(ring)
def ring_area(ring):
"""Aire signee (formule du lacet) ; le signe depend du sens de parcours."""
pts = np.asarray(ring, dtype=float)
x, y = pts[:, 0], pts[:, 1]
return 0.5 * float(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1)))
def ring_centroid(ring):
"""Barycentre de la surface delimitee par un anneau."""
pts = np.asarray(ring, dtype=float)
x, y = pts[:, 0], pts[:, 1]
xn, yn = np.roll(x, -1), np.roll(y, -1)
cross = x * yn - xn * y
area = cross.sum() / 2.0
if area == 0:
return float(x.mean()), float(y.mean())
return (float(((x + xn) * cross).sum() / (6 * area)),
float(((y + yn) * cross).sum() / (6 * area)))
def scale_rings(rings, factor, offset=(0.0, 0.0)):
"""Multiplie les coordonnees des anneaux puis les decale."""
ox, oy = offset
return [[(x * factor + ox, y * factor + oy) for x, y in ring] for ring in rings]
# --------------------------------------------------------------------------
# Verification du placement des formes sur la planche
# --------------------------------------------------------------------------