def test_downscaling_valueerror(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(1, 0),
Vector(1, 1),
Vector(0, 1)])
self.assertRaises(ValueError, lambda: poly.downscale(2))
def test_path(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
path = cover_polygon2d_with_path(poly, Vector(1, 1), 1, 0.5, 0.0)
def test_point_of_polygon(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
point = poly.get_point_on_polygon(10)
segment, point = point.get_segment_and_vector()
def test_init(self):
v = Vector(1, 2, 3)
assert v.x == 1
assert v.y == 2
assert v.z == 3
v = Vector((3.1416, 6.2832, 1.41421))
assert v.x == 3.1416
assert v.y == 6.2832
assert v.z == 1.41421
def triangle_from_string(cls, str):
assert len(str) >= 50
bytes, str = str[:50], str[50:]
coords = struct.unpack('ffffffffffffH', bytes)
normal = Vector(coords[:3])
vertex1 = Vector(coords[3:6])
vertex2 = Vector(coords[6:9])
vertex3 = Vector(coords[9:12])
t = Triangle(vertex1, vertex2, vertex3, normal)
return (t, str)
def test_to_path(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
path1 = poly.to_path(0.1, Vector(1, 1))
path2 = Path.from_to(Vector(0, 0), Vector(10, 0), Vector(1, 1), 0.1)
intersects = list(path1.get_intersecting_boxes(path2))
self.assertGreater(len(intersects), 1)
def from_input_file(self, inf):
triangleList = []
R = inf.read()
words = re.split('\W+', R)
if 'facet' in words and 'normal' in words and 'vertex' in words:
# this is an ASCII STL file
del words
lines = re.split('\n', R)
self.preamble = lines.pop(0)
while lines:
line = lines.pop(0).strip()
words = re.split('[ \t]+', line)
if words[0] == 'endsolid':
break
assert words[0] == 'facet' and words[1] == 'normal', words
normal = Vector(string.atof(words[2]),
string.atof(words[3]),
string.atof(words[4]))
vertices = []
line = lines.pop(0).strip()
assert line == 'outer loop', line
for i in range(3):
line = lines.pop(0).strip()
words = re.split('[ \t]+', line)
assert words[0] == 'vertex', words
vertex = Vector(string.atof(words[1]),
string.atof(words[2]),
string.atof(words[3]))
vertices.append(vertex)
line = lines.pop(0).strip()
assert line == 'endloop', line
line = lines.pop(0).strip()
assert line == 'endfacet', line
tri = apply(Triangle, vertices + [normal])
triangleList.append(tri)
else:
# this is a binary STL file
self.preamble = ''.join(filter(lambda ch: ch != '\0',
list(R[:80])))
R = R[80:]
numTriangles, R = struct.unpack('I', R[:4])[0], R[4:]
for i in range(numTriangles):
tri, R = self.triangle_from_string(R)
triangleList.append(tri)
return triangleList
def test_copy(self):
bbox1 = BBox(Vector(1, 2, 3), Vector(4, 5, 6))
bbox2 = bbox1.copy()
bbox1._max = Vector(7, 8, 9)
assert bbox2._min == Vector(1, 2, 3)
assert bbox2._max == Vector(4, 5, 6)
assert bbox1._min == Vector(1, 2, 3)
assert bbox1._max == Vector(7, 8, 9)
def test_iter_from(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
self.assertEqual(
list(poly.iter_from(12)),
[Vector(10, 0),
Vector(10, 10),
Vector(0, 10),
Vector(0, 0)])
def test_path(self):
path1 = Path.from_to(Vector(0, 0), Vector(10, 0), Vector(1, 1), 0.1)
path2 = Path.from_to(Vector(10, 10), Vector(10, 0), Vector(1, 1), 0.1)
intersecting_boxes = list(path1.get_intersecting_boxes(path2))
self.assertGreater(len(intersecting_boxes), 1)
self.assertTrue(path1.does_collide(path2))
def te_st_get_point_list(self):
A = Vector(0, 0, 0)
B = Vector(1, 0, 0)
C = Vector(0, 1, 0)
D = Vector(0, 0, 1)
stl = Stl(Triangle(A, B, D), Triangle(A, C, B), Triangle(A, D, C),
Triangle(B, C, D))
tz = stl.triangles
(I, _), (J, _) = stl.get_point_list(0.25, 0.25, tz)
assert approximate(I.x, 0)
assert approximate(I.y, 0.25)
assert approximate(I.z, 0.25)
assert approximate(J.x, 0.5)
assert approximate(J.y, 0.25)
assert approximate(J.z, 0.25)
assert stl.get_point_list(2, 2) == []
assert stl.get_point_list(1, 1) == []
(I, _), = stl.get_point_list(0.5, 0.5)
assert approximate(I.x, 0)
assert approximate(I.y, 0.5)
assert approximate(I.z, 0.5)
def test_nonintersecting(self):
pc = [
Coordinates(50.022313, 21.990220),
Coordinates(50.022935, 21.990492),
Coordinates(50.021613, 21.991670),
Coordinates(50.021544, 21.991540),
Coordinates(50.022149, 21.991335),
Coordinates(50.021385, 21.992079)
]
xy_pc = XYPointCollection(pc)
poly1 = Polygon2D([xypoint.to_vector() for xypoint in xy_pc[:3]])
poly2 = Polygon2D([xypoint.to_vector() for xypoint in xy_pc[3:]])
path1 = cover_polygon2d_with_path(poly1, Vector(5, 5, 5), 10, 0.3, 0)
path1.set_z(50)
path2 = cover_polygon2d_with_path(poly2, Vector(5, 5, 5), 10, 0.3, 0)
path2.set_z(50)
path1, path2 = make_nonintersecting([
MakeNonintersectingPaths(0, 100, path1),
MakeNonintersectingPaths(0, 100, path2)
])
self.assertGreater(path2.length, 400)
self.assertTrue(are_mutually_nonintersecting([path1, path2]))
path1.simplify()
path2.simplify()
def test_collision(self):
box1 = Box(Vector(0, 0, 0), Vector(10, 10, 10))
box2 = Box(Vector(5, 5, 5), Vector(15, 15, 15))
box3 = Box(Vector(20, 20, 20), Vector(25, 25, 25))
self.assertTrue(box1.collides(box2))
self.assertTrue(box2.collides(box1))
self.assertFalse(box1.collides(box3))
self.assertFalse(box2.collides(box3))
self.assertFalse(box3.collides(box1))
self.assertFalse(box3.collides(box2))
def test_make_nonintersecting(self):
p1 = Path.from_to(Vector(0, 0, 2), Vector(10, 10, 2), Vector(1, 1, 1),
0.1)
p2 = Path.from_to(Vector(5, 5, 2), Vector(15, 15, 2), Vector(1, 1, 1),
0.1)
self.assertTrue(p1.does_collide(p2))
m1 = MakeNonintersectingPaths(-5, 10, p1)
m2 = MakeNonintersectingPaths(-5, 10, p2)
p1, p2, = make_nonintersecting([m1, m2])
self.assertFalse(p1.does_collide(p2))
def test_get_unit_vector_towards_polygon(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
self.assertEqual(poly.total_perimeter_length, 40)
self.assertEqual(poly.len_segments, [10, 10, 10, 10])
point = poly.get_point_on_polygon(0)
self.assertEqual(point.get_unit_vector_towards_polygon(),
Vector(1, 1).unitize())
point.advance(5)
self.assertEqual(point.to_vector(), Vector(5, 0))
self.assertEqual(point.get_unit_vector_towards_polygon(), Vector(0, 1))
self.assertEqual(point.get_unit_vector_away_polygon(), Vector(0, -1))
point.advance(-10)
self.assertEqual(point.to_vector(), Vector(0, 5))
self.assertEqual(point.get_unit_vector_towards_polygon(), Vector(1, 0))
point = poly.get_point_on_polygon(10)
self.assertTrue(point.is_on_vertex())
self.assertEqual(point.get_unit_vector_towards_polygon(),
Vector(-1, 1).unitize())
def test_downscaling(self):
poly = Polygon2D(
[Vector(0, 0),
Vector(10, 0),
Vector(10, 10),
Vector(0, 10)])
poly = poly.downscale(1)
self.assertEqual(poly.points[0], Vector(1, 1).unitize())
self.assertEqual(poly.points[1],
Vector(10, 0) + Vector(-1, 1).unitize())
self.assertEqual(poly.points[2],
Vector(10, 10) + Vector(-1, -1).unitize())
self.assertEqual(poly.points[3],
Vector(0, 10) + Vector(1, -1).unitize())
def test_eq(self):
assert Vector(1.0, 2.0, 3.0) == \
Vector(1.00000000001, 1.999999999999, 3.0)
assert Vector(1.0, 2.0, 3.0) != Vector(1.00001, 1.9999, 3.0)
def test_point_contains(self):
poly = Polygon2D([Vector(0, 0, 0), Vector(1, 0, 0), Vector(1, 1, 0)])
self.assertIn(Vector(0.5, 0.5, 0), poly)
self.assertIn(Vector(0, 0, 0), poly)
self.assertNotIn(Vector(2, 0.5, 0), poly)
self.assertNotIn(Vector(2, 2, 0), poly)
def test_unit_length(self):
p = (1. / 3)**.5
v = Vector(1, 1, 1).unit_length()
assert v == Vector(p, p, p)
def test_dot(self):
v = Vector(1, 2, 3)
assert v.dot(Vector(4, 5, 6)) == 32
def test_size(self):
assert BBox(Vector(0, -1, 0), Vector(1, 1,
3)).size() == Vector(1, 2, 3)
def test_abs(self):
v = Vector(1, 2, 3)
expected = (1 + 4 + 9)**.5
assert abs(v) == expected
def test_contains(self):
bbox = BBox(Vector(0, 0, 0), Vector(1, 1, 1))
assert Vector(0.5, 0.5, 0.5) in bbox
assert Vector(0.5, 0.5, 1.1) not in bbox
def test_diff(self):
assert Vector(4, 6, 8).diff(Vector(1, 2, 3)) == Vector(3, 4, 5)
def test_add(self):
v = Vector(4, 6, 8)
assert v.add(Vector(1, 2, 3)) == Vector(5, 8, 11)
def test_cross(self):
v = Vector(1, 2, 3)
assert v.cross(Vector(4, 5, 6)) == Vector(-3, 6, -3)
def test_add(self):
v = Vector(4, 6, 8)
assert v.add(Vector(1, 2, 3)) == Vector(5, 8, 11)
def test_cross(self):
v = Vector(1, 2, 3)
assert v.cross(Vector(4, 5, 6)) == Vector(-3, 6, -3)
def test_set_size(self):
bbox = BBox(Vector(0, 0, 0), Vector(1, 1, 1))
bbox.set_size(Vector(2, 3, 4))
assert bbox._min == Vector(-0.5, -1.0, -1.5)
assert bbox._max == Vector(1.5, 2.0, 2.5)
def test_getXiterator(self):
bb = BBox(Vector(0.0, 0.0, 1.0), Vector(1.0, 2.0, 4.0))
assert [x for x in bb.getXiterator(5)] == \
[0.0, 0.25, 0.5, 0.75, 1.0]
assert [x for x in bb.getXiterator(5)] == \
[0.0, 0.25, 0.5, 0.75, 1.0]
def test_point_closest(self):
poly = Polygon2D([Vector(0, 0, 0), Vector(1, 0, 0), Vector(1, 1, 0)])
closest = poly.get_closest_to(Vector(0.5, -0.5, 0), 10)
self.assertLess(abs(closest - 0.5), 0.01)
closest = poly.get_closest_to(Vector(2, 2, 0), 10)
self.assertLess(abs(closest - 2), 0.01)
def test_init(self):
bbox = BBox(Vector(0, 0, 0), Vector(1, 1, 1))
assert bbox._min == Vector(0, 0, 0)
assert bbox._max == Vector(1, 1, 1)
def test_scale(self):
assert Vector(1, 2, 3).scale(2) == Vector(2, 4, 6)
