Alex/inkscape.decoupeFlexible
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
inkscape.decoupeFlexible/test_living_hinge.py
Alex eb9308a8d4 Version initiale
2026-10-01 15:21:24 +02:00

480 lines
20 KiB
Python
Raw Permalink Blame History

# coding=utf-8
"""Tests de l'extension « Living Hinge Fill » (pytest)."""
import math
import os
import random
import re
import xml.etree.ElementTree as ET
import pytest
from living_hinge_core import (bounding_box, clear_intervals, hinge_slots, parse_color,
polylines_to_d, random_spans, regular_spans, rotate,
slot_length, slot_outline, slots_to_d)
HERE = os.path.dirname(os.path.abspath(__file__))
SHAPES = os.path.join(HERE, "tests", "data", "shapes.svg")
RECT = [[(0.0, 0.0), (60.0, 0.0), (60.0, 80.0), (0.0, 80.0)]]
# Rectangle troue (pair-impair)
HOLED = [RECT[0], [(20.0, 30.0), (40.0, 30.0), (40.0, 50.0), (20.0, 50.0)]]
DIMS = dict(length=20.0, width=3.0, bridge=2.0, pitch=5.0)
def circle(cx, cy, r, n=180):
return [(cx + r * math.cos(2 * math.pi * k / n), cy + r * math.sin(2 * math.pi * k / n))
for k in range(n)]
def distance_to_segment(p, a, b):
ex, ey = b[0] - a[0], b[1] - a[1]
norm = ex * ex + ey * ey
t = 0.0 if norm == 0 else max(0.0, min(1.0, ((p[0] - a[0]) * ex + (p[1] - a[1]) * ey) / norm))
return math.hypot(p[0] - a[0] - t * ex, p[1] - a[1] - t * ey)
def distance_to_boundary(p, rings):
return min(distance_to_segment(p, ring[k], ring[(k + 1) % len(ring)])
for ring in rings for k in range(len(ring)))
def is_inside(p, rings):
inside = False
for ring in rings:
for k in range(len(ring)):
(x1, y1), (x2, y2) = ring[k], ring[(k + 1) % len(ring)]
if (y1 <= p[1]) != (y2 <= p[1]) and p[0] < x1 + (p[1] - y1) * (x2 - x1) / (y2 - y1):
inside = not inside
return inside
# --------------------------------------------------------------------------
# Noyau (sans inkex) : utilitaires
# --------------------------------------------------------------------------
def test_parse_color_inkscape_integer():
assert parse_color("3014898687") == ("#b3b3b3", 1.0)
assert parse_color(str(0xFF000080)) == ("#ff0000", round(0x80 / 255, 4))
assert parse_color("255") == ("#000000", 1.0)
def test_parse_color_hex_and_invalid():
assert parse_color("#123456") == ("#123456", 1.0)
assert parse_color("#abc") == ("#aabbcc", 1.0)
assert parse_color("pas une couleur") == ("#b3b3b3", 1.0)
def test_polylines_to_d():
d = polylines_to_d([[(0, 0), (1, 2)], [(3, 4), (5, 6)]], precision=1)
assert d == "M 0.0,0.0 L 1.0,2.0 M 3.0,4.0 L 5.0,6.0"
def test_bounding_box():
assert bounding_box(HOLED) == (0.0, 0.0, 60.0, 80.0)
assert bounding_box([]) is None
def test_rotate_counter_clockwise_on_screen():
# y vers le bas : un point a droite du centre monte (y diminue).
x, y = rotate((1.0, 0.0), 90)
assert abs(x) < 1e-12 and abs(y + 1.0) < 1e-12
x, y = rotate((3.0, 2.0), 180, center=(2.0, 2.0))
assert abs(x - 1.0) < 1e-12 and abs(y - 2.0) < 1e-12
def test_clear_intervals_rectangle():
assert clear_intervals(RECT, 30.0) == [(0.0, 80.0)]
(y0, y1), = clear_intervals(RECT, 30.0, 5.0)
assert abs(y0 - 5.0) < 1e-6 and abs(y1 - 75.0) < 1e-6
# Trop pres du bord gauche, ou hors de la forme
assert clear_intervals(RECT, 3.0, 5.0) == []
assert clear_intervals(RECT, 70.0) == []
def test_clear_intervals_hole_and_corner():
low, high = clear_intervals(HOLED, 30.0, 2.0)
assert abs(low[1] - 28.0) < 1e-6 and abs(high[0] - 52.0) < 1e-6
# A cote du trou : la zone interdite s'arrondit autour de ses coins.
(_y0, y1), (y2, _y3) = clear_intervals(HOLED, 18.0, 4.0)
reach = math.sqrt(4.0 ** 2 - 2.0 ** 2)
assert abs(y1 - (30.0 - reach)) < 1e-6 and abs(y2 - (50.0 + reach)) < 1e-6
# --------------------------------------------------------------------------
# Noyau (sans inkex) : motif
# --------------------------------------------------------------------------
def test_slots_stay_inside_with_margin():
for rings in (RECT, HOLED, [circle(50, 50, 40), circle(50, 50, 10)]):
for angle in (0.0, 30.0, 90.0):
slots = hinge_slots(rings, margin=2.0, angle=angle, **DIMS)
assert slots
for slot in slots:
for point in slot_outline(slot, 1.5):
assert is_inside(point, rings)
assert distance_to_boundary(point, rings) >= 2.0 - 1e-6
def test_slot_lengths_and_minimum():
slots = hinge_slots(RECT, margin=2.0, min_length=6.0, **DIMS)
lengths = [slot_length(slot, 3.0) for slot in slots]
assert max(lengths) <= 20.0 + 1e-9
assert min(lengths) >= 6.0 - 1e-9
assert any(abs(value - 20.0) < 1e-9 for value in lengths) # lumieres entieres
assert any(value < 20.0 - 1e-6 for value in lengths) # et raccourcies
# Un minimum plus haut ecarte des lumieres raccourcies, jamais les entieres.
full_only = hinge_slots(RECT, margin=2.0, min_length=20.0, **DIMS)
assert 0 < len(full_only) < len(slots)
assert all(abs(slot_length(slot, 3.0) - 20.0) < 1e-9 for slot in full_only)
def test_columns_pitch_bridge_and_stagger():
slots = hinge_slots(RECT, margin=2.0, **DIMS)
columns = {}
for (x0, y0), (x1, y1) in slots:
assert x0 == x1 and y0 <= y1 # lumieres verticales
columns.setdefault(round(x0, 6), []).append((y0 - 1.5, y1 + 1.5))
xs = sorted(columns)
assert all(abs(b - a - 5.0) < 1e-9 for a, b in zip(xs, xs[1:]))
assert 30.0 in xs # motif centre sur la forme
assert xs[0] >= 3.5 and xs[-1] <= 56.5 # demi-largeur + marge
for spans in columns.values():
spans.sort()
for (_a, end), (start, _b) in zip(spans, spans[1:]):
assert abs(start - end - 2.0) < 1e-9 # pont entre deux lumieres
# Quinconce : decalage d'une demi-periode (22 / 2) entre colonnes voisines.
even = {round(end % 22.0, 6) for _start, end in columns[30.0][:-1]}
odd = {round(end % 22.0, 6) for _start, end in columns[35.0][:-1]}
assert len(even) == 1 and len(odd) == 1
assert abs(abs(even.pop() - odd.pop()) - 11.0) < 1e-6
def test_stagger_zero_aligns_columns():
slots = hinge_slots(RECT, margin=2.0, stagger=0.0, **DIMS)
spans = {}
for (x0, y0), (_x1, y1) in slots:
spans.setdefault(round(x0, 6), []).append((round(y0, 6), round(y1, 6)))
assert len(spans) > 1
assert len(set(map(tuple, spans.values()))) == 1
def test_angle_90_gives_horizontal_slots():
slots = hinge_slots(RECT, margin=2.0, angle=90.0, **DIMS)
assert slots
for (x0, y0), (x1, y1) in slots:
assert abs(y0 - y1) < 1e-9 and abs(x1 - x0) > 1.0
def test_hole_is_avoided():
slots = hinge_slots(HOLED, margin=2.0, **DIMS)
for slot in slots:
for x, y in slot_outline(slot, 1.5):
assert not (18.0 + 1e-6 < x < 42.0 - 1e-6 and 28.0 + 1e-6 < y < 52.0 - 1e-6)
assert len(slots) != len(hinge_slots(RECT, margin=2.0, **DIMS))
def test_regular_spans():
spans = regular_spans(0.0, 100.0, 5.0, 20.0, 2.0)
assert all(size == 20.0 for _start, size in spans)
starts = [start for start, _size in spans]
assert 5.0 in starts and starts[0] + 20.0 > 0.0 and starts[-1] <= 100.0
assert all(abs(b - a - 22.0) < 1e-9 for a, b in zip(starts, starts[1:]))
def test_random_spans_fill_exactly():
# Toutes sortes de hauteurs : la zone est remplie pile, d'un bout a l'autre.
for k in range(200):
low, high = 10.0, 10.0 + 25.0 + 1.37 * k
spans = random_spans(low, high, 3.0, 20.0, 2.0, random.Random(k))
assert abs(spans[0][0] - low) < 1e-9
assert abs(spans[-1][0] + spans[-1][1] - high) < 1e-9
assert all(3.0 - 1e-9 <= size <= 20.0 + 1e-9 for _start, size in spans)
for (start, size), (following, _s) in zip(spans, spans[1:]):
assert abs(following - start - size - 2.0) < 1e-9 # pont constant
# Reproductible, et different d'un tirage a l'autre.
args = (0.0, 500.0, 3.0, 20.0, 2.0)
assert random_spans(*args, random.Random(1)) == random_spans(*args, random.Random(1))
assert random_spans(*args, random.Random(1)) != random_spans(*args, random.Random(2))
def test_random_spans_tight_cases():
rng = random.Random(0)
# Zone plus courte que la plus courte lumiere : une seule, qui la remplit.
assert random_spans(0.0, 4.0, 6.0, 20.0, 2.0, rng) == [(0.0, 4.0)]
# Zone d'une lumiere pile.
assert random_spans(5.0, 15.0, 3.0, 20.0, 2.0, rng) == [(5.0, 10.0)]
# Aucun compte ne tombe juste (bornes egales) : lumieres egales, zone remplie.
spans = random_spans(0.0, 76.0, 20.0, 20.0, 2.0, rng)
assert len({round(size, 9) for _start, size in spans}) == 1
assert spans[0][0] == 0.0 and abs(spans[-1][0] + spans[-1][1] - 76.0) < 1e-9
assert random_spans(3.0, 3.0, 3.0, 20.0, 2.0, rng) == []
def test_random_columns_start_and_end_at_margin():
# Dans un rectangle, toutes les colonnes commencent et finissent au meme niveau.
slots = hinge_slots(RECT, margin=2.0, random_min=3.0, seed=4, **DIMS)
columns = {}
for (x0, y0), (_x1, y1) in slots:
columns.setdefault(round(x0, 6), []).append((y0 - 1.5, y1 + 1.5))
assert len(columns) == 11
for spans in columns.values():
assert abs(min(a for a, _b in spans) - 2.0) < 1e-6
assert abs(max(b for _a, b in spans) - 78.0) < 1e-6
# Autour d'un trou aussi : chaque zone libre est remplie d'un bord a l'autre.
slots = hinge_slots(HOLED, margin=2.0, random_min=3.0, seed=4, **DIMS)
middle = sorted((y0 - 1.5, y1 + 1.5) for (x0, y0), (_x1, y1) in slots if x0 == 30.0)
ends = [b for _a, b in middle]
starts = [a for a, _b in middle]
assert abs(starts[0] - 2.0) < 1e-6 and abs(ends[-1] - 78.0) < 1e-6
assert any(abs(b - 28.0) < 1e-6 for b in ends)
assert any(abs(a - 52.0) < 1e-6 for a in starts)
def test_random_lengths():
big = [[(0.0, 0.0), (200.0, 0.0), (200.0, 300.0), (0.0, 300.0)]]
slots = hinge_slots(big, margin=2.0, random_min=3.0, seed=7, **DIMS)
assert slots == hinge_slots(big, margin=2.0, random_min=3.0, seed=7, **DIMS)
assert slots != hinge_slots(big, margin=2.0, random_min=3.0, seed=8, **DIMS)
lengths = [slot_length(slot, 3.0) for slot in slots]
assert min(lengths) >= 3.0 - 1e-9 and max(lengths) <= 20.0 + 1e-9
assert min(lengths) < 6.0 and max(lengths) > 17.0 # toute la plage sert
assert len({round(value, 3) for value in lengths}) > len(lengths) / 2
# Pas des colonnes et pont inchanges, lumieres a la marge.
columns = {}
for (x0, y0), (x1, y1) in slots:
assert x0 == x1
assert 3.5 - 1e-6 <= y0 and y1 <= 296.5 + 1e-6
columns.setdefault(round(x0, 6), []).append((y0 - 1.5, y1 + 1.5))
xs = sorted(columns)
assert all(abs(b - a - 5.0) < 1e-9 for a, b in zip(xs, xs[1:]))
for spans in columns.values():
spans.sort()
for (_a, end), (start, _b) in zip(spans, spans[1:]):
assert abs(start - end - 2.0) < 1e-9
# Les colonnes ne sont pas des copies les unes des autres.
assert len({tuple(round(v, 3) for span in spans for v in span)
for spans in columns.values()}) == len(columns)
def test_random_min_is_clamped_and_respects_shape():
# Minimum sous la largeur : ramene a la largeur (trou rond au plus petit).
slots = hinge_slots(HOLED, margin=2.0, random_min=0.0, seed=3, **DIMS)
assert slots
for slot in slots:
assert slot_length(slot, 3.0) >= 3.0 - 1e-9
for point in slot_outline(slot, 1.5):
assert is_inside(point, HOLED)
assert distance_to_boundary(point, HOLED) >= 2.0 - 1e-6
# Minimum ramene a la longueur : plus de hasard, lumieres egales d'une marge a l'autre.
slots = hinge_slots(RECT, margin=2.0, random_min=50.0, seed=3, **DIMS)
assert slots and len({round(slot_length(slot, 3.0), 6) for slot in slots}) == 1
def test_full_slot_shorter_than_minimum_is_kept():
# min_length ne vise que les lumieres raccourcies par le bord.
slots = hinge_slots(RECT, length=5.0, width=3.0, bridge=2.0, pitch=5.0, min_length=9.0)
assert slots and all(abs(slot_length(slot, 3.0) - 5.0) < 1e-9 for slot in slots)
def test_degenerate_inputs():
assert hinge_slots([], **DIMS) == []
assert hinge_slots([[(0, 0), (1, 1)]], **DIMS) == []
assert hinge_slots([[(0, 0), (4, 0), (4, 4), (0, 4)]], margin=2.0, **DIMS) == []
assert hinge_slots(RECT, length=2.0, width=3.0, bridge=2.0, pitch=5.0) == []
assert hinge_slots(RECT, length=20.0, width=0.0, bridge=2.0, pitch=5.0) == []
assert hinge_slots(RECT, length=20.0, width=3.0, bridge=2.0, pitch=0.0) == []
def test_slot_outline_is_at_radius_of_axis():
slot = ((10.0, 10.0), (10.0, 30.0))
outline = slot_outline(slot, 2.0, segments=8)
assert all(abs(a - b) < 1e-9 for a, b in zip(outline[0], outline[-1]))
for point in outline:
assert abs(distance_to_segment(point, *slot) - 2.0) < 1e-9
ys = [y for _x, y in outline]
assert abs(min(ys) - 8.0) < 1e-9 and abs(max(ys) - 32.0) < 1e-9
def test_slots_to_d():
d = slots_to_d([((10.0, 10.0), (10.0, 30.0))], 2.0, precision=1)
assert d == ("M 8.0,10.0 L 8.0,30.0 A 2.0 2.0 0 0 0 12.0,30.0 "
"L 12.0,10.0 A 2.0 2.0 0 0 0 8.0,10.0 Z")
# Lumiere reduite a un cercle : deux arcs, pas de segment nul.
circle_d = slots_to_d([((5.0, 5.0), (5.0, 5.0))], 1.0, precision=0)
assert circle_d == "M 4,5 A 1 1 0 0 0 6,5 A 1 1 0 0 0 4,5 Z"
assert slots_to_d([], 1.0) == ""
assert slots_to_d([((0, 0), (0, 9)), ((5, 0), (5, 9))], 1.0).count("Z") == 2
# --------------------------------------------------------------------------
# Bout en bout (necessite inkex)
# --------------------------------------------------------------------------
def run_extension(tmp_path, *args):
pytest.importorskip("inkex")
from living_hinge import LivingHinge
out = tmp_path / "out.svg"
if out.exists():
out.unlink()
LivingHinge().run([*args, "--output={}".format(out), SHAPES])
# inkex n'ecrit rien quand le document n'a pas change (erreur utilisateur).
return out.read_text(encoding="utf-8") if out.exists() else ""
def generated_paths(svg):
"""Chemins ajoutes par l'extension (ceux du fichier d'exemple ont un id connu)."""
root = ET.fromstring(svg)
return [elem for elem in root.iter()
if elem.tag.endswith("}path") and elem.get("id") not in ("path1", "path2")]
def test_end_to_end_default(tmp_path):
svg = run_extension(tmp_path, "--id=rect1")
assert "Living hinge" in svg
assert 'id="rect1"' in svg
paths = generated_paths(svg)
assert len(paths) == 1 # un seul chemin pour toutes les lumieres
assert paths[0].get("d").count("Z") >= 10
assert "fill:none" in paths[0].get("style")
def test_end_to_end_slots_inside_rect(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--margin=2")
d = generated_paths(svg)[0].get("d")
points = [(float(x), float(y)) for x, y in re.findall(r"(-?[\d.]+),(-?[\d.]+)", d)]
assert points
# rect1 : x 10..60, y 10..50 ; les raccords droite / arc restent a la marge
# en x, et a marge + rayon en y (le bout arrondi depasse d'un rayon).
assert all(12.0 - 1e-3 <= x <= 58.0 + 1e-3 for x, _y in points)
assert all(13.5 - 1e-3 <= y <= 46.5 + 1e-3 for _x, y in points)
def test_end_to_end_all_shapes_and_group(tmp_path):
svg = run_extension(tmp_path, "--id=circle1", "--id=path1", "--id=path2", "--id=group1")
assert svg.count("Living hinge") == 4
assert len(generated_paths(svg)) == 4
# Le groupe d'accueil neutralise la translation du groupe parent.
assert re.search(r'transform="translate\(-100,? ?-65\)"', svg)
def test_end_to_end_units_and_angle(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--unit=cm", "--slot_length=2",
"--slot_width=0.3", "--bridge=0.2", "--pitch=0.5",
"--margin=0.2", "--min_length=0.6", "--stroke_width=0.02",
"--angle=90")
assert "A 1.5000 1.5000" in svg
assert re.search(r"stroke-width:0\.2\d*[;\"]", svg)
def test_end_to_end_errors(tmp_path, capsys):
svg = run_extension(tmp_path) # pas de selection
assert "Living hinge" not in svg
svg = run_extension(tmp_path, "--id=rect1", "--pitch=2") # pas <= largeur
assert "Living hinge" not in svg
svg = run_extension(tmp_path, "--id=rect1", "--slot_length=1") # longueur < largeur
assert "Living hinge" not in svg
svg = run_extension(tmp_path, "--id=rect1", "--margin=30") # rien ne tient
assert "Living hinge" not in svg
errors = capsys.readouterr().err
assert "Select at least one shape" in errors
assert "column pitch" in errors and "slot length" in errors and "too small" in errors
def arc_starts(svg):
"""Debut de chaque lumiere du chemin genere (un « M x,y » par lumiere)."""
return re.findall(r"M (-?[\d.]+,-?[\d.]+)", generated_paths(svg)[0].get("d"))
def test_end_to_end_random(tmp_path):
regular = run_extension(tmp_path, "--id=path2")
first = run_extension(tmp_path, "--id=path2", "--random_lengths=true")
again = run_extension(tmp_path, "--id=path2", "--random_lengths=true")
other = run_extension(tmp_path, "--id=path2", "--random_lengths=true", "--seed=2")
assert arc_starts(first) == arc_starts(again) # meme graine, meme motif
assert arc_starts(first) != arc_starts(other)
assert arc_starts(first) != arc_starts(regular)
assert len(arc_starts(first)) > len(arc_starts(regular)) # lumieres plus courtes
def test_end_to_end_random_error(tmp_path, capsys):
svg = run_extension(tmp_path, "--id=rect1", "--random_lengths=true", "--random_min=25")
assert "Living hinge" not in svg
assert "shortest random slot" in capsys.readouterr().err
def test_end_to_end_removes_original(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--keep_original=false")
assert 'id="rect1"' not in svg
def test_end_to_end_color(tmp_path):
svg = run_extension(tmp_path, "--id=rect1", "--stroke_color={}".format(0x336699FF))
assert re.search(r"stroke:#336699", svg)
# --------------------------------------------------------------------------
# Traductions
# --------------------------------------------------------------------------
def test_translations_up_to_date_and_complete():
"""Chaque texte du .inx et des .py a sa traduction dans chaque catalogue."""
import gettext
import i18n
msgids = [msgid for msgid, _refs in i18n.extract()]
assert "Living Hinge Fill" in msgids
assert "mm" not in msgids # unites marquees translatable="no"
for language in i18n.LANGUAGES:
entries = i18n.read_po(i18n.po_path(language))
missing = [m for m in msgids if not entries.get(m, ("", False))[0]]
assert not missing, "{}.po incomplet : {}".format(language, missing)
catalog = gettext.translation(i18n.DOMAIN, i18n.LOCALE_DIR, [language])
for msgid in msgids:
assert catalog.gettext(msgid) == entries[msgid][0], \
"{} : .mo a recompiler (python i18n.py)".format(language)
def test_po_roundtrip(tmp_path):
import i18n
messages = [("Simple", ["a"]), ('Quote "x" and \\ back', ["a"]),
("Two\nlines", ["a"]), ("Tab\tend\n", ["a"])]
path = str(tmp_path / "xx.po")
i18n.write_po(path, "fr", messages,
{m: ("<" + m + ">", False) for m, _r in messages})
entries = i18n.read_po(path)
for msgid, _refs in messages:
assert entries[msgid] == ("<" + msgid + ">", False)
def test_inx_matches_arguments():
"""Chaque <param> du .inx a son add_argument, memes noms et memes defauts."""
root = ET.parse(os.path.join(HERE, "living_hinge.inx")).getroot()
params = {elem.get("name"): (elem.text or "").strip() for elem in root.iter()
if elem.tag.rsplit("}", 1)[-1] == "param"}
with open(os.path.join(HERE, "living_hinge.py"), encoding="utf-8") as handle:
source = handle.read()
arguments = dict(re.findall(r'add_argument\("--(\w+)",.*?default=([^)]+)\)', source))
assert set(params) == set(arguments)
for name, default in arguments.items():
if name in ("tab", "unit"):
continue
value = default.strip('"')
if params[name] in ("true", "false"):
assert value.lower() == params[name], name
elif name == "stroke_color":
assert value == params[name], name
else:
assert float(value) == float(params[name]), name
def test_inx_images_exist():
"""Les images de la boite de dialogue sont presentes (chemin relatif au .inx)."""
root = ET.parse(os.path.join(HERE, "living_hinge.inx")).getroot()
for elem in root.iter():
if elem.tag.rsplit("}", 1)[-1] == "image":
assert os.path.isfile(os.path.join(HERE, elem.text.strip())), elem.text
Reference in New Issue View Git Blame Copy Permalink