def test_intersect_at_boundary(self):
nodes = np.asfortranarray([[0.0, 0.5, 1.0], [0.0, -0.25, 0.0]])
curve = self._make_one(nodes, 2)
left, right = curve.subdivide()
result = left.intersect(right)
# The "right" end of ``left`` and the "left" end of ``right``.
expected = np.asfortranarray([[1.0], [0.0]])
self.assertEqual(result, expected)
def test_intersect_at_boundary(self):
nodes = np.asfortranarray([
[0.0, 0.0],
[0.5, -0.25],
[1.0, 0.0],
])
curve = self._make_one(nodes, 2)
left, right = curve.subdivide()
result = left.intersect(right)
expected = np.asfortranarray([[0.5, -0.125]])
self.assertEqual(result, expected)
def _subdivide_helper(self, nodes, expected_l, expected_r):
klass = self._get_target_class()
curve = klass.from_nodes(nodes)
left, right = curve.subdivide()
self.assertIs(left.root, curve)
self.assertIs(right.root, curve)
self.assertIsInstance(left, klass)
self.assertEqual(left._nodes, expected_l)
self.assertIsInstance(right, klass)
self.assertEqual(right._nodes, expected_r)
def test_subdivide_multilevel_root(self):
curve = self._make_one(self.ZEROS, 1)
left, right = curve.subdivide()
self.assertIs(left.root, curve)
self.assertIs(right.root, curve)
one, two = left.subdivide()
three, four = right.subdivide()
self.assertIs(one.root, curve)
self.assertIs(two.root, curve)
self.assertIs(three.root, curve)
self.assertIs(four.root, curve)
def test_subdivide(self):
nodes = np.asfortranarray([[0.0, 4.0], [1.0, 6.0]])
klass = self._get_target_class()
curve = klass.from_nodes(nodes)
# Call ``subdivide()`` and then compare.
left, right = curve.subdivide()
# Check the "left" sub-curve.
self.assertEqual(left._degree, 1)
self.assertIsInstance(left, klass)
expected_l = np.asfortranarray([[0.0, 2.0], [1.0, 3.5]])
self.assertEqual(left._nodes, expected_l)
# Check the "right" sub-curve.
self.assertIsInstance(right, klass)
expected_r = np.asfortranarray([[2.0, 4.0], [3.5, 6.0]])
self.assertEqual(right._nodes, expected_r)
def _subdivide_points_check(self, curve, pts_exponent=5):
# Using the exponent means that ds = 1/2**exp, which
# can be computed without roundoff.
num_pts = 2**pts_exponent + 1
left, right = curve.subdivide()
left_half = np.linspace(0.0, 0.5, num_pts)
right_half = np.linspace(0.5, 1.0, num_pts)
unit_interval = np.linspace(0.0, 1.0, num_pts)
pairs = [
(left, left_half),
(right, right_half),
]
for sub_curve, half in pairs:
# Make sure sub_curve([0, 1]) == curve(half)
main_vals = curve.evaluate_multi(half)
sub_vals = sub_curve.evaluate_multi(unit_interval)
self.assertEqual(main_vals, sub_vals)
def test_againt_subdivision(self):
import bezier
nodes = np.asfortranarray([
[0.0, 1.0],
[1.0, 6.0],
[3.0, 5.0],
])
curve = bezier.Curve(nodes, 2)
left, right = curve.subdivide()
left_nodes, true_start, true_end = self._call_function_under_test(
nodes, 0.0, 0.5, 0.0, 1.0, 2)
self.assertEqual(left.nodes, left_nodes)
self.assertEqual(true_start, left.start)
self.assertEqual(true_end, left.end)
right_nodes, true_start, true_end = self._call_function_under_test(
nodes, 0.5, 1.0, 0.0, 1.0, 2)
self.assertEqual(right.nodes, right_nodes)
self.assertEqual(true_start, right.start)
self.assertEqual(true_end, right.end)
