# Copyright (c) 2010-2020 Manfred Moitzi # License: MIT License import pytest import random from ezdxf.math import ( cubic_bezier_interpolation, Vec3, Vec2, Bezier3P, quadratic_to_cubic_bezier, Bezier4P, have_bezier_curves_g1_continuity, bezier_to_bspline, split_bezier, quadratic_bezier_from_3p, close_vectors, cubic_bezier_bbox, quadratic_bezier_bbox, intersection_ray_cubic_bezier_2d, ) def test_vertex_interpolation(): points = [(0, 0), (3, 1), (5, 3), (0, 8)] result = list(cubic_bezier_interpolation(points)) assert len(result) == 3 c1, c2, c3 = result p = c1.control_points assert p[0].isclose((0, 0)) assert p[1].isclose((0.9333333333333331, 0.3111111111111111)) assert p[2].isclose((1.8666666666666663, 0.6222222222222222)) assert p[3].isclose((3, 1)) p = c2.control_points assert p[0].isclose((3, 1)) assert p[1].isclose((4.133333333333334, 1.3777777777777778)) assert p[2].isclose((5.466666666666667, 1.822222222222222)) assert p[3].isclose((5, 3)) p = c3.control_points assert p[0].isclose((5, 3)) assert p[1].isclose((4.533333333333333, 4.177777777777778)) assert p[2].isclose((2.2666666666666666, 6.088888888888889)) assert p[3].isclose((0, 8)) def test_invalid_bezier_interpolation(): """At least 3 points are required.""" assert len(list(cubic_bezier_interpolation([(0, 0)]))) == 0 assert len(list(cubic_bezier_interpolation([(0, 0), (1, 0)]))) == 0 def test_quadratic_to_cubic_bezier(): r = random.Random(0) def random_vec() -> Vec3: return Vec3(r.uniform(-10, 10), r.uniform(-10, 10), r.uniform(-10, 10)) for i in range(1000): quadratic = Bezier3P((random_vec(), random_vec(), random_vec())) quadratic_approx = list(quadratic.approximate(10)) cubic = quadratic_to_cubic_bezier(quadratic) cubic_approx = list(cubic.approximate(10)) assert len(quadratic_approx) == len(cubic_approx) for p1, p2 in zip(quadratic_approx, cubic_approx): assert p1.isclose(p2) # G1 continuity: normalized end-tangent == normalized start-tangent of next curve B1 = Bezier4P(Vec2.list([(0, 0), (1, 1), (2, 1), (3, 0)])) # B1/B2 has G1 continuity: B2 = Bezier4P(Vec2.list([(3, 0), (4, -1), (5, -1), (6, 0)])) # B1/B3 has no G1 continuity: B3 = Bezier4P(Vec2.list([(3, 0), (4, 1), (5, 1), (6, 0)])) # B1/B4 G1 continuity off tolerance: B4 = Bezier4P(Vec2.list([(3, 0), (4, -1.03), (5, -1.0), (6, 0)])) # B1/B5 has a gap between B1 end and B5 start: B5 = Bezier4P(Vec2.list([(4, 0), (5, -1), (6, -1), (7, 0)])) def test_g1_continuity_for_bezier_curves(): assert have_bezier_curves_g1_continuity(B1, B2) is True assert have_bezier_curves_g1_continuity(B1, B3) is False assert ( have_bezier_curves_g1_continuity(B1, B4, g1_tol=1e-4) is False ), "should be outside of tolerance " assert ( have_bezier_curves_g1_continuity(B1, B5) is False ), "end- and start point should match" D1 = Bezier4P(Vec2.list([(0, 0), (1, 1), (3, 0), (3, 0)])) D2 = Bezier4P(Vec2.list([(3, 0), (3, 0), (5, -1), (6, 0)])) def test_g1_continuity_for_degenerated_bezier_curves(): assert have_bezier_curves_g1_continuity(D1, B2) is False assert have_bezier_curves_g1_continuity(B1, D2) is False assert have_bezier_curves_g1_continuity(D1, D2) is False @pytest.mark.parametrize("curve", [D1, D2]) def test_flatten_degenerated_bezier_curves(curve): # Degenerated Bezier curves behave like regular curves! assert len(list(curve.flattening(0.1))) > 4 @pytest.mark.parametrize( "b1,b2", [ (B1, B2), # G1 continuity, the common case (B1, B3), # without G1 continuity is also a regular B-spline (B1, B5), # regular B-spline, but first control point of B5 is lost ], ids=["G1", "without G1", "gap"], ) def test_bezier_curves_to_bspline(b1, b2): bspline = bezier_to_bspline([b1, b2]) # Remove duplicate control point between two adjacent curves: expected = list(b1.control_points) + list(b2.control_points)[1:] assert bspline.degree == 3, "should be a cubic B-spline" assert bspline.control_points == tuple(expected) def test_quality_of_bezier_to_bspline_conversion_1(): # This test shows the close relationship between cubic Bézier- and # cubic B-spline curves. points0 = B1.approximate(10) points1 = bezier_to_bspline([B1]).approximate(10) for p0, p1 in zip(points0, points1): assert p0.isclose(p1) is True, "conversion should be perfect" def test_quality_of_bezier_to_bspline_conversion_2(): # This test shows the close relationship between cubic Bézier- and # cubic B-spline curves. # Remove duplicate point between the two curves: points0 = list(B1.approximate(10)) + list(B2.approximate(10))[1:] points1 = bezier_to_bspline([B1, B2]).approximate(20) for p0, p1 in zip(points0, points1): assert p0.isclose(p1) is True, "conversion should be perfect" def test_bezier_curves_to_bspline_error(): with pytest.raises(ValueError): bezier_to_bspline([]) # one or more curves expected class TestSplitBezier: @pytest.fixture def points3(self): return Vec2.list([(0, 0), (0, 1), (1.5, 0.75), (2, 2)]) @pytest.mark.parametrize("t", [-1, 2]) def test_t_validation(self, points3, t): with pytest.raises(ValueError): split_bezier(points3, t) def test_control_point_validation(self): with pytest.raises(ValueError): split_bezier([Vec2(0, 0)], 0.5) def test_split_cubic_bezier(self, points3): left, right = split_bezier(points3, 0.5) assert ( close_vectors( left, [(0.0, 0.0), (0.0, 0.5), (0.375, 0.6875), (0.8125, 0.90625)], ) is True ) assert ( close_vectors( right, [(2.0, 2.0), (1.75, 1.375), (1.25, 1.125), (0.8125, 0.90625)], ) is True ) def test_quadratic_bezier_from_3_points(): qbez = quadratic_bezier_from_3p((0, 0), (3, 2), (6, 0)) assert qbez.point(0.5).isclose((3, 2)) def test_cubic_bezier_from_3_points(): cbez = quadratic_bezier_from_3p((0, 0), (3, 2), (6, 0)) assert cbez.point(0.5).isclose((3, 2)) class TestBezierCurveBoundingBox: def test_linear_curve(self): bbox = cubic_bezier_bbox(Bezier4P(Vec2.list([(0, 0), (1, 1), (2, 2), (3, 3)]))) assert bbox.extmin == (0, 0, 0) assert bbox.extmax == (3, 3, 0) def test_reverse_linear_curve(self): bbox = cubic_bezier_bbox( Bezier4P(Vec2.list([(3, 3), (2, 2), (-2, -2), (-3, -3)])) ) assert bbox.extmin == (-3, -3, 0) assert bbox.extmax == (3, 3, 0) def test_cubic_bezier_curve_with_one_extrema(self): curve = Bezier4P(Vec2.list([(0, 0), (0, 1), (2, 1), (2, 0)])) bbox = cubic_bezier_bbox(curve) assert bbox.extmax.y == pytest.approx(0.75) def test_cubic_bezier_curve_with_two_extrema(self): curve = Bezier4P(Vec2.list([(0, 0), (0, 1), (2, -1), (2, 0)])) bbox = cubic_bezier_bbox(curve) assert bbox.extmin.y == pytest.approx(-0.28867513459481287) assert bbox.extmax.y == pytest.approx(+0.28867513459481287) def test_closed_3d_cubic_bezier_curve(self): curve = Bezier4P(Vec3.list([(0, 0, -1), (2, 3, 0), (-2, 3, 0), (0, 0, -1)])) bbox = cubic_bezier_bbox(curve) assert bbox.extmin.x == pytest.approx(-0.5773502691896258) assert bbox.extmin.z == pytest.approx(-1.0) assert bbox.extmax.x == pytest.approx(+0.5773502691896258) assert bbox.extmax.y == pytest.approx(+2.25) assert bbox.extmax.z == pytest.approx(-0.25) def test_quadratic_bezier_curve_box(self): curve = Bezier3P(Vec2.list([(0, 0), (1, 1), (2, 0)])) bbox = quadratic_bezier_bbox(curve) assert bbox.extmax.y == pytest.approx(0.5) class TestRayCubicBezierCurve2dIntersection: @pytest.fixture(scope="class") def curve(self): return Bezier4P(Vec2.list([(0, -2), (2, 6), (4, -6), (6, 2)])) def test_no_intersection(self, curve): assert len(intersection_ray_cubic_bezier_2d((0, -6), (1, -6), curve)) == 0 def test_one_intersection_point(self, curve): points = intersection_ray_cubic_bezier_2d((3, -6), (3, 6), curve) assert len(points) == 1 assert points[0].isclose((3, 0)) def test_two_intersection_points(self, curve): points = intersection_ray_cubic_bezier_2d((-1.4, -2.5), (7.1, 3.9), curve) assert len(points) == 2 expected = ( (0.18851028511733303, -1.3039451970881237), (2.5249135145844264, 0.4552289992165126), ) assert all(p.isclose(e) for e, p in zip(expected, points)) is True def test_three_intersection_points(self, curve): points = intersection_ray_cubic_bezier_2d((0, 0), (1, 0), curve) assert len(points) == 3 expected = ( (0.6762099922755492, 0.0), (3.0, 0.0), (5.323790007724451, 0.0), ) assert all(p.isclose(e) for e, p in zip(expected, points)) is True def test_collinear_ray_and_curve(self): curve = Bezier4P(Vec2.list([(0, 0), (1, 0), (2, 0), (3, 0)])) ip = intersection_ray_cubic_bezier_2d((0, 0), (1, 0), curve) assert len(ip) == 1 assert ip[0].isclose((0, 0)) # ??? @pytest.mark.parametrize("x", [0, 0.5, 1, 3]) def test_linear_ray_and_curve(self, x): curve = Bezier4P(Vec2.list([(0, 0), (1, 0), (2, 0), (3, 0)])) # ray defined in +y direction ip = intersection_ray_cubic_bezier_2d((x, -1), (x, 0), curve) assert len(ip) == 1 assert ip[0].isclose((x, 0)) # ray defined in -y direction ip = intersection_ray_cubic_bezier_2d((x, 2), (x, 1), curve) assert len(ip) == 1 assert ip[0].isclose((x, 0))