192 lines
6.1 KiB
Python
192 lines
6.1 KiB
Python
from pathlib import Path
|
|
|
|
import numpy
|
|
from numpy.testing import assert_equal, assert_allclose
|
|
from numpy import pi
|
|
import pytest
|
|
|
|
from ..utils import remove_duplicate_vertices, remove_colinear_vertices, poly_contains_points, rotation_matrix_2d, apply_transforms, normalize_mirror, DeferredDict
|
|
from ..file.utils import tmpfile
|
|
from ..utils.curves import bezier
|
|
from ..error import PatternError
|
|
|
|
|
|
def test_remove_duplicate_vertices() -> None:
|
|
# Closed path (default)
|
|
v = [[0, 0], [1, 1], [1, 1], [2, 2], [0, 0]]
|
|
v_clean = remove_duplicate_vertices(v, closed_path=True)
|
|
# The last [0,0] is a duplicate of the first [0,0] if closed_path=True
|
|
assert_equal(v_clean, [[0, 0], [1, 1], [2, 2]])
|
|
|
|
# Open path
|
|
v_clean_open = remove_duplicate_vertices(v, closed_path=False)
|
|
assert_equal(v_clean_open, [[0, 0], [1, 1], [2, 2], [0, 0]])
|
|
|
|
|
|
def test_remove_colinear_vertices() -> None:
|
|
v = [[0, 0], [1, 0], [2, 0], [2, 1], [2, 2], [1, 1], [0, 0]]
|
|
v_clean = remove_colinear_vertices(v, closed_path=True)
|
|
# [1, 0] is between [0, 0] and [2, 0]
|
|
# [2, 1] is between [2, 0] and [2, 2]
|
|
# [1, 1] is between [2, 2] and [0, 0]
|
|
assert_equal(v_clean, [[0, 0], [2, 0], [2, 2]])
|
|
|
|
|
|
def test_remove_colinear_vertices_exhaustive() -> None:
|
|
# U-turn
|
|
v = [[0, 0], [10, 0], [0, 0]]
|
|
v_clean = remove_colinear_vertices(v, closed_path=False, preserve_uturns=True)
|
|
# Open path should keep ends. [10,0] is between [0,0] and [0,0]?
|
|
# They are colinear, but it's a 180 degree turn.
|
|
# We preserve 180 degree turns if preserve_uturns is True.
|
|
assert len(v_clean) == 3
|
|
|
|
v_collapsed = remove_colinear_vertices(v, closed_path=False, preserve_uturns=False)
|
|
# If not preserving u-turns, it should collapse to just the endpoints
|
|
assert len(v_collapsed) == 2
|
|
|
|
# 180 degree U-turn in closed path
|
|
v = [[0, 0], [10, 0], [5, 0]]
|
|
v_clean = remove_colinear_vertices(v, closed_path=True, preserve_uturns=False)
|
|
assert len(v_clean) == 2
|
|
|
|
|
|
def test_poly_contains_points() -> None:
|
|
v = [[0, 0], [10, 0], [10, 10], [0, 10]]
|
|
pts = [[5, 5], [-1, -1], [10, 10], [11, 5]]
|
|
inside = poly_contains_points(v, pts)
|
|
assert_equal(inside, [True, False, True, False])
|
|
|
|
|
|
def test_rotation_matrix_2d() -> None:
|
|
m = rotation_matrix_2d(pi / 2)
|
|
assert_allclose(m, [[0, -1], [1, 0]], atol=1e-10)
|
|
|
|
|
|
def test_rotation_matrix_non_manhattan() -> None:
|
|
# 45 degrees
|
|
m = rotation_matrix_2d(pi / 4)
|
|
s = numpy.sqrt(2) / 2
|
|
assert_allclose(m, [[s, -s], [s, s]], atol=1e-10)
|
|
|
|
|
|
def test_apply_transforms() -> None:
|
|
# cumulative [x_offset, y_offset, rotation (rad), mirror_x (0 or 1)]
|
|
t1 = [10, 20, 0, 0]
|
|
t2 = [[5, 0, 0, 0], [0, 5, 0, 0]]
|
|
combined = apply_transforms(t1, t2)
|
|
assert_equal(combined, [[15, 20, 0, 0, 1], [10, 25, 0, 0, 1]])
|
|
|
|
|
|
def test_apply_transforms_advanced() -> None:
|
|
# Ox4: (x, y, rot, mir)
|
|
# Outer: mirror x (axis 0), then rotate 90 deg CCW
|
|
# apply_transforms logic for mirror uses y *= -1 (which is axis 0 mirror)
|
|
outer = [0, 0, pi / 2, 1]
|
|
|
|
# Inner: (10, 0, 0, 0)
|
|
inner = [10, 0, 0, 0]
|
|
|
|
combined = apply_transforms(outer, inner)
|
|
# 1. mirror inner y if outer mirrored: (10, 0) -> (10, 0)
|
|
# 2. rotate by outer rotation (pi/2): (10, 0) -> (0, 10)
|
|
# 3. add outer offset (0, 0) -> (0, 10)
|
|
assert_allclose(combined[0], [0, 10, pi / 2, 1, 1], atol=1e-10)
|
|
|
|
|
|
def test_apply_transforms_empty_inputs() -> None:
|
|
empty_outer = apply_transforms(numpy.empty((0, 5)), [[1, 2, 0, 0, 1]])
|
|
assert empty_outer.shape == (0, 5)
|
|
|
|
empty_inner = apply_transforms([[1, 2, 0, 0, 1]], numpy.empty((0, 5)))
|
|
assert empty_inner.shape == (0, 5)
|
|
|
|
both_empty_tensor = apply_transforms(numpy.empty((0, 5)), numpy.empty((0, 5)), tensor=True)
|
|
assert both_empty_tensor.shape == (0, 0, 5)
|
|
|
|
|
|
def test_normalize_mirror_validates_length() -> None:
|
|
with pytest.raises(ValueError, match='2-item sequence'):
|
|
normalize_mirror(())
|
|
|
|
with pytest.raises(ValueError, match='2-item sequence'):
|
|
normalize_mirror((True,))
|
|
|
|
with pytest.raises(ValueError, match='2-item sequence'):
|
|
normalize_mirror((True, False, True))
|
|
|
|
|
|
def test_bezier_validates_weight_length() -> None:
|
|
with pytest.raises(PatternError, match='one entry per control point'):
|
|
bezier([[0, 0], [1, 1]], [0, 0.5, 1], weights=[1])
|
|
|
|
with pytest.raises(PatternError, match='one entry per control point'):
|
|
bezier([[0, 0], [1, 1]], [0, 0.5, 1], weights=[1, 2, 3])
|
|
|
|
|
|
def test_bezier_accepts_exact_weight_count() -> None:
|
|
samples = bezier([[0, 0], [1, 1]], [0, 0.5, 1], weights=[1, 2])
|
|
assert_allclose(samples, [[0, 0], [2 / 3, 2 / 3], [1, 1]], atol=1e-10)
|
|
|
|
|
|
def test_deferred_dict_accessors_resolve_values_once() -> None:
|
|
calls = 0
|
|
|
|
def make_value() -> int:
|
|
nonlocal calls
|
|
calls += 1
|
|
return 7
|
|
|
|
deferred = DeferredDict[str, int]()
|
|
deferred["x"] = make_value
|
|
|
|
assert deferred.get("missing", 9) == 9
|
|
assert deferred.get("x") == 7
|
|
assert list(deferred.values()) == [7]
|
|
assert list(deferred.items()) == [("x", 7)]
|
|
assert calls == 1
|
|
|
|
|
|
def test_deferred_dict_mutating_accessors_preserve_value_semantics() -> None:
|
|
calls = 0
|
|
|
|
def make_value() -> int:
|
|
nonlocal calls
|
|
calls += 1
|
|
return 7
|
|
|
|
deferred = DeferredDict[str, int]()
|
|
|
|
assert deferred.setdefault("x", 5) == 5
|
|
assert deferred["x"] == 5
|
|
|
|
assert deferred.setdefault("y", make_value) == 7
|
|
assert deferred["y"] == 7
|
|
assert calls == 1
|
|
|
|
copy_deferred = deferred.copy()
|
|
assert isinstance(copy_deferred, DeferredDict)
|
|
assert copy_deferred["x"] == 5
|
|
assert copy_deferred["y"] == 7
|
|
assert calls == 1
|
|
|
|
assert deferred.pop("x") == 5
|
|
assert deferred.pop("missing", 9) == 9
|
|
assert deferred.popitem() == ("y", 7)
|
|
|
|
|
|
def test_tmpfile_cleans_up_on_exception(tmp_path: Path) -> None:
|
|
target = tmp_path / "out.txt"
|
|
temp_path = None
|
|
|
|
try:
|
|
with tmpfile(target) as stream:
|
|
temp_path = Path(stream.name)
|
|
stream.write(b"hello")
|
|
raise RuntimeError("boom")
|
|
except RuntimeError:
|
|
pass
|
|
|
|
assert temp_path is not None
|
|
assert not target.exists()
|
|
assert not temp_path.exists()
|