def test_handles_convex_polygons(self):
"""
The original Delaunay algorithm always outputs a convex polygon
so, let us make sure that the boundary stays the same if it is concave
"""
v1 = Vertex(0, 0, 10, 0)
v2 = Vertex(1, 10, 0, 0)
v3 = Vertex(2, 4, 0, 0)
v4 = Vertex(3, 4, 4, 0)
face = [v1, v2, v3, v4]
triangles = triangulate(face)
self.assertEqual(len(triangles), 2)
# There is only one way to triangulate this polygon, so that it preserves the boundary
tri1 = [v1, v2, v4]
tri2 = [v2, v3, v4]
tri1_present = False
if self.isTrianglesEqual(tri1, triangles[0]):
tri1_present = True
elif self.isTrianglesEqual(tri1, triangles[1]):
tri1_present = True
tri2_present = False
if self.isTrianglesEqual(tri2, triangles[0]):
tri2_present = True
elif self.isTrianglesEqual(tri2, triangles[1]):
tri2_present = True
self.assertTrue(tri1_present)
self.assertTrue(tri2_present)
def setUp(self) -> None:
self.v1 = Vertex(0, 0, 3, 0)
self.v2 = Vertex(1, 0, 4, 0)
self.v3 = Vertex(2, 0, 3, 1)
self.face1 = Face(0, self.v1, self.v2, self.v3)
self.face2 = Face(1, self.v3, self.v2, self.v1)
def setUp(self) -> None:
self.v1 = Vertex(0, 0, 0, 0)
self.v2 = Vertex(1, 1, 0, 0)
self.v3 = Vertex(2, 0, 1, 0)
self.v4 = Vertex(0, 0, 0, 1)
self.edge = Edge(0, self.v1, self.v3, EDGE_VALLEY)
self.face1 = Face(1, self.v1, self.v2, self.v3)
self.face2 = Face(2, self.v1, self.v3, self.v4)
def test_does_not_change_triangular_face(self):
face = [Vertex(0, 1, 0, 0), Vertex(1, 2, 0, 0), Vertex(2, 0, 2, 0)]
triangulated = triangulate(face)
self.assertEqual(len(triangulated), 1)
triangulated_pos_set = set(map(lambda v: v.pos, triangulated[0]))
pos_set = set(map(lambda v: v.pos, face))
self.assertEqual(pos_set, triangulated_pos_set)
def setUp(self) -> None:
self.v1 = Vertex(0, 1, -1, 0)
self.v2 = Vertex(1, 1, 1, 0)
self.v3 = Vertex(2, -1, 1, 0)
self.v4 = Vertex(3, -1, -1, 0)
self.face1 = Face(0, self.v1, self.v2, self.v4)
self.face2 = Face(1, self.v2, self.v3, self.v4)
self.edge = Edge(2, self.v4, self.v2, EDGE_UNKNOWN)
self.edge.face_right = self.face1
self.edge.face_left = self.face2
def test_normalize_bounding(self):
verts = [Vertex(0, 1.0, 1.0, 1.0), Vertex(1, -20.0, -20.0, -20.0)]
scale_fac = verts[1].pos.length / 5.0
normalized = normalize_bounding_box(verts, 10)
self.assertEqual(
normalized[0].pos,
Vector3(1.0 / scale_fac, 1.0 / scale_fac, 1.0 / scale_fac))
self.assertEqual(
normalized[1].pos,
Vector3(-20.0 / scale_fac, -20.0 / scale_fac, -20.0 / scale_fac))
def test_triangulates_square_along_yz_plane(self):
face = [
Vertex(0, 0, 0, 0),
Vertex(1, 0, 1, 0),
Vertex(2, 0, 1, 1),
Vertex(3, 0, 0, 1),
]
triangulated = triangulate(face)
diagonal1 = np.array([0, 1, 1])
diagonal2 = np.array([0, -1, 1])
self.assertTriangulatesSquare(triangulated, diagonal1, diagonal2)
def test_handles_numerical_stability_in_disjoint_check(self):
"""
Looks strange, this test case is a real-life scenario that happened.
Disjointness check is "too-precise", sometimes even for convex polygons, it
would return too little triangles from the triangulation
"""
v1 = Vertex(0, 3, 0, 0)
v2 = Vertex(1, 4, 0, 0)
v3 = Vertex(2, 4.571428571428572, 1.428571428571428, 0)
v4 = Vertex(3, 3.047619047619047, 0.9523809523809523, 0)
face = [v1, v2, v3, v4]
triangles = triangulate(face)
self.assertEqual(len(triangles), 2)
def test_does_nothing_for_already_translated(self):
verts = [
Vertex(1, 1.0, 1.0, 1.0),
Vertex(2, 1.0, 1.0, -1.0),
Vertex(4, 1.0, -1.0, 1.0),
Vertex(5, -1.0, 1.0, 1.0),
Vertex(6, -1.0, -1.0, 1.0),
Vertex(7, 1.0, -1.0, -1.0),
Vertex(8, -1.0, 1.0, -1.0),
Vertex(9, -1.0, -1.0, -1.0),
]
initial_positions = list(map(lambda v: v.pos, verts))
trans = list(translate_to_origin(verts))
self.assertEqual(initial_positions, list(map(lambda v: v.pos, trans)))
def test_does_nothing_for_vertices_on_the_edge(self):
verts = [
Vertex(1, 1.0, 1.0, 1.0),
Vertex(2, 1.0, 1.0, -1.0),
Vertex(4, 1.0, -1.0, 1.0),
Vertex(5, -1.0, 1.0, 1.0),
Vertex(6, -1.0, -1.0, 1.0),
Vertex(7, 1.0, -1.0, -1.0),
Vertex(8, -1.0, 1.0, -1.0),
Vertex(9, -1.0, -1.0, -1.0),
]
initial_positions = list(map(lambda v: v.pos, verts))
normalized = normalize_bounding_box(verts, 2 * math.sqrt(3))
self.assertEqual(initial_positions,
list(map(lambda v: v.pos, normalized)))
def setUp(self) -> None:
self.v1 = Vertex(0, 0, 0, 0)
self.v2 = Vertex(1, 2, 0, 0)
self.edge = Edge(0, self.v1, self.v2, EDGE_BOUNDARY)
def test_returns_zero_length(self):
edge = Edge(0, Vertex(0, 0, 0, 0), Vertex(1, 0, 0, 0), EDGE_VALLEY)
self.assertEqual(edge.length, 0)
def setUp(self) -> None:
self.v = Vertex(0, 0, 0, 0)
def test_does_nothing_when_all_correctly_bound(self):
verts = [Vertex(0, 0.0, 0.0, 0.0), Vertex(1, 1.0, 1.0, 1.0)]
normalized = normalize_bounding_box(verts, 2 * math.sqrt(3))
self.assertEqual(list(map(lambda vert: vert.pos, normalized)),
[Vector3(0, 0, 0), Vector3(1, 1, 1)])
def test_translates_to_origin(self):
verts = [
Vertex(1, 2.0, 2.0, 1.0),
Vertex(2, 2.0, 2.0, -1.0),
Vertex(4, 2.0, 0.0, 1.0),
Vertex(5, -0.0, 2.0, 1.0),
Vertex(6, -0.0, 0.0, 1.0),
Vertex(7, 2.0, 0.0, -1.0),
Vertex(8, -0.0, 2.0, -1.0),
Vertex(9, -0.0, 0.0, -1.0),
]
trans = list(map(lambda v: v.pos, translate_to_origin(verts)))
expected_trans = list(
map(lambda v: v.pos, [
Vertex(1, 1.0, 1.0, 1.0),
Vertex(2, 1.0, 1.0, -1.0),
Vertex(4, 1.0, -1.0, 1.0),
Vertex(5, -1.0, 1.0, 1.0),
Vertex(6, -1.0, -1.0, 1.0),
Vertex(7, 1.0, -1.0, -1.0),
Vertex(8, -1.0, 1.0, -1.0),
Vertex(9, -1.0, -1.0, -1.0),
]))
self.assertEqual(trans, expected_trans)
def test_zero_division_does_not_throw(self):
verts = [Vertex(0, 0, 0, 0)]
normalize_bounding_box(verts, 10)
def setUp(self) -> None:
self.v1 = Vertex(0, 1, 0, 0)
self.v2 = Vertex(1, -1, 0, 0)
self.v3 = Vertex(2, 0, 2, 0)
self.face = Face(0, self.v1, self.v2, self.v3)
def setUp(self) -> None:
self.v1 = Vertex(0, 0, 0, 0)
self.v2 = Vertex(1, 1, 1, 0)
self.edge = Edge(0, self.v1, self.v2, EDGE_FLAT)