def test_join_same_level(self):
a = LineSegment((0, 0), (1, 1))
b = LineSegment((2, 2), (3, 3))
c = LineSegment((5, 5), (10, 10))
flatten = flatten_line_segment([a,b,c],a.unit_vector)
joined = flatten[0.0]
self.assertEqual(joined.a, (0, 0))
self.assertEqual(joined.b, (10, 10))
def test_add_segment_middle(self):
a = (0, 0)
b = (10, 10)
c = (2, 2)
d = (4, 4)
segment = LineSegment(a, b)
to_add = LineSegment(c, d)
segment.add_segment(to_add)
self.assertEqual(segment.a, a)
self.assertEqual(segment.b, b)
def test_add_segment_after(self):
c = (5, 5)
d = (10, 10)
a = (0, 0)
b = (4, 4)
segment = LineSegment(a, b)
to_add = LineSegment(c, d)
segment.add_segment(to_add)
self.assertEqual(segment.a, a)
self.assertEqual(segment.b, d)
def test_add_segment_before(self):
a = (5, 5)
b = (10, 10)
c = (0, 0)
d = (4, 4)
segment = LineSegment(a, b)
to_add = LineSegment(c, d)
segment.add_segment(to_add)
self.assertEqual(segment.a, c)
self.assertEqual(segment.b, b)
def test_default_angle(self):
"""
The angle shold by default test the vector with (1,0)
"""
a = (0, 0)
b = (0, 10)
segment = LineSegment(a, b)
angle = segment.get_angle()
expected_angle = round(math.pi/2, segment.angle_precision)
self.assertEqual(angle, expected_angle)
def test_join_varying_level(self):
a = LineSegment((0, 0), (0, 1))
b = LineSegment((0, 2), (0, 5))
c = LineSegment((15, 2), (15, 10))
flatten = flatten_line_segment([a,b,c],a.unit_vector,gap_epsilon=6)
# CHecking it respected the levels erasing the merged ones
self.assertIn(0.0, flatten)
self.assertNotIn(3.0, flatten)
self.assertIn(15.0, flatten)
joined = flatten[0.0]
self.assertEqual(joined.a, a.a)
self.assertEqual(joined.b, b.b)
self.assertEqual(flatten[15.0], c)
def test_right_order(self):
"""
Test that a line segment instantiate the original order if both A and B are on the right orer
"""
segment = LineSegment((0, 0), (5, 0))
self.assertEqual(segment.a, (0, 0))
self.assertEqual(segment.b, (5, 0))
def test_unit_vector(self):
"""
Test that a line segment makes the right unit vector
"""
a = (0, 5)
b = (10, 10)
segment = LineSegment(a, b)
unit = [segment.x/segment.length, segment.y/segment.length]
self.assertEqual(segment.unit_vector, unit)
def test_A_y_after(self):
"""
Test that a line segment instantiate the inverser order if A.x is after b
"""
a = (0, 1)
b = (0, 0)
segment = LineSegment(a, b)
self.assertEqual(segment.a, b)
self.assertEqual(segment.b, a)
def test_segment_skiping(self):
"""
Check if segments less than min are skipped until min is reached
"""
points = [(0, 0), (2, 0), (5, 0)]
angle_map = build_segments_angle_map(points, min_size=5)
self.assertIn(0.0, angle_map)
segment = LineSegment(points[0], points[2])
lines = angle_map[0.0].lines
self.assertEqual(len(lines), 1)
self.assertEqual(lines[0], segment)
def test_vector_creation(self):
"""
Test if the vetor is actualy created
"""
a = (1, 1)
b = (10, 2)
segment = LineSegment(a, b)
vector = [b[0]-a[0], b[1]-a[1]]
self.assertEqual(segment.x, vector[0])
self.assertEqual(segment.y, vector[1])
length = (vector[0]**2 + vector[1]**2)**0.5
self.assertEqual(segment.length, length)
def test_segment_indexing(self):
points = self.perfect_5_box
angle_map = build_segments_angle_map(points)
zero_segments = angle_map[0.0]
# Checking if the pivot point is the first vector
segment = LineSegment(points[0], points[1])
self.assertEqual(zero_segments.pivotPoint, segment.vector)
self.assertEqual(zero_segments.norm, segment.unit_vector)
lines = zero_segments.lines
self.assertIn(segment, lines)
segment = LineSegment(points[2], points[3])
self.assertIn(segment, lines)
ninety_segments = angle_map[ninety_degrees]
segment = LineSegment(points[1], points[2])
self.assertEqual(ninety_segments.pivotPoint, segment.vector)
self.assertEqual(ninety_segments.norm, segment.unit_vector)
lines = ninety_segments.lines
self.assertIn(segment, lines)
segment = LineSegment(points[3], points[4])
self.assertIn(segment, lines)
def test_angle_flatten(self):
def check_seg_in_list(angle, flatten, to_check):
segments = flatten[angle].lines
projected = to_check.get_projected_segment(flatten[angle].norm)
for segment in segments:
if projected == segment:
return True
return False
angleDict = {}
segments = []
for i in range(0, 16, 2):
segments.append(LineSegment((i, i), (i + 1, i + 1)))
uv = segments[0].unit_vector
lines = [segments[0], segments[1]]
ok = LineGroup(uv, None, segments)
angle_ok = 0.0
angleDict[angle_ok] = ok
uv = segments[2].unit_vector
lines = [segments[2], segments[3]]
to_flat = LineGroup(uv, None, lines)
angle_flatten = angle_ok + minRadAngle
angleDict[angle_flatten] = to_flat
uv = segments[4].unit_vector
lines = [segments[4], segments[5]]
ok2 = LineGroup(uv, None, lines)
angle_ok_2 = angle_flatten + 0.1
angleDict[angle_ok_2] = ok2
uv = segments[6].unit_vector
lines = [segments[6], segments[7]]
not_flatten = LineGroup(uv, None, lines)
angle_not_flatten = angle_ok_2 + minRadAngle + 0.2
angleDict[angle_not_flatten] = not_flatten
flatten = flatten_angles(angleDict)
self.assertNotIn(angle_flatten, flatten)
self.assertIn(angle_ok, flatten)
self.assertIn(angle_ok_2, flatten)
self.assertIn(angle_not_flatten, flatten)
to_check = flatten[angle_ok].lines
self.assertIn(ok.lines[0], to_check)
segment = to_flat.lines[0]
self.assertTrue(check_seg_in_list(angle_ok, flatten, segment))
self.assertIn(ok.lines[0], to_check)
segment = to_flat.lines[1]
self.assertTrue(check_seg_in_list(angle_ok, flatten, segment))
to_check = flatten[angle_ok_2].lines
self.assertIn(ok2.lines[0], to_check)
self.assertIn(ok2.lines[1], to_check)
to_check = flatten[angle_not_flatten].lines
self.assertIn(not_flatten.lines[0], to_check)
self.assertIn(not_flatten.lines[1], to_check)
