def test_contains(self):
""
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
# point
self.assertTrue(hl.contains(P0))
self.assertTrue(hl.contains(P0+vL))
self.assertTrue(hl.contains(P0+vL*10))
self.assertFalse(hl.contains(P0+vL.opposite))
self.assertFalse(hl.contains(P0+vL.perp_vector))
# segment
self.assertTrue(hl.contains(Segment(P0,P0+vL)))
self.assertTrue(hl.contains(Segment(P0+vL,P0+vL*2)))
self.assertFalse(hl.contains(Segment(P0+vL*-1,P0)))
self.assertFalse(hl.contains(Segment(P0+vL*-2,P0+vL*-1)))
self.assertFalse(hl.contains(Segment(P0+vL.perp_vector,P0+vL+vL.perp_vector)))
P0,vL=Point(0,0,0),Vector(1,1,1)
hl=Halfline(P0,vL)
# point
self.assertTrue(hl.contains(P0))
self.assertTrue(hl.contains(P0+vL))
self.assertTrue(hl.contains(P0+vL*10))
self.assertFalse(hl.contains(P0+vL.opposite))
self.assertFalse(hl.contains(P0+Vector(1,-1,0)))
# segment
self.assertTrue(hl.contains(Segment(P0,P0+vL)))
self.assertTrue(hl.contains(Segment(P0+vL,P0+vL*2)))
self.assertFalse(hl.contains(Segment(P0+vL*-1,P0)))
self.assertFalse(hl.contains(Segment(P0+vL*-2,P0+vL*-1)))
self.assertFalse(hl.contains(Segment(P0+Vector(1,-1,0),P0+vL+Vector(1,-1,0))))
def test_opposite(self):
""
v = Vector(1, 0)
self.assertEqual(v.opposite, Vector(-1, 0))
v = Vector(1, 0, 0)
self.assertEqual(v.opposite, Vector(-1, 0, 0))
def test_split(self):
""
# 2d
pg = Polygon(Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1))
pl = Polyline(Point(0.5, 0), Point(0.5, 1))
self.assertEqual(
pg.split(pl),
GeometryObjects(
Polygon(Point(0.5, 0.0), Point(0.0, 0.0), Point(0.0, 1.0),
Point(0.5, 1.0)),
Polygon(Point(0.5, 1.0), Point(1.0, 1.0), Point(1.0, 0.0),
Point(0.5, 0.0))))
pg = Polygon(Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1))
l = Line(Point(0.5, 0), Vector(0, 1))
self.assertEqual(
pg.split(l),
GeometryObjects(
Polygon(Point(0.5, 0.0), Point(0.0, 0.0), Point(0.0, 1.0),
Point(0.5, 1.0)),
Polygon(Point(0.5, 1.0), Point(1.0, 1.0), Point(1.0, 0.0),
Point(0.5, 0.0))))
# 3d
pg = Polygon(Point(0, 0, 1), Point(1, 0, 1), Point(1, 1, 1),
Point(0, 1, 1))
l = Line(Point(0.5, 0, 1), Vector(0, 1, 0))
#print(pg.split(l)); return
self.assertEqual(
pg.split(l),
GeometryObjects(
Polygon(Point(0.5, 0.0, 1.0), Point(0.0, 0.0, 1.0),
Point(0.0, 1.0, 1.0), Point(0.5, 1.0, 1.0)),
Polygon(Point(0.5, 1.0, 1.0), Point(1.0, 1.0, 1.0),
Point(1.0, 0.0, 1.0), Point(0.5, 0.0, 1.0))))
def test_project_2D(self):
""
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertEqual(l.project_2D(0), Line(Point(0, 0), Vector(1, 1)))
self.assertEqual(l.project_2D(1), Line(Point(0, 0), Vector(1, 1)))
self.assertEqual(l.project_2D(2), Line(Point(0, 0), Vector(1, 1)))
def test___mul__(self):
""
v = Vector(1, 0)
self.assertEqual(v * 2, Vector(2, 0))
v = Vector(1, 0, 0)
self.assertEqual(v * 2, Vector(2, 0, 0))
def test_length(self):
""
v = Vector(1, 0)
self.assertEqual(v.length, 1)
v = Vector(1, 0, 0)
self.assertEqual(v.length, 1)
def test_normalise(self):
""
v = Vector(2, 0)
self.assertEqual(v.normalise, Vector(1, 0))
v = Vector(2, 0, 0)
self.assertEqual(v.normalise, Vector(1, 0, 0))
def test_base_polygon_and_extrud_vector(self):
""
ph = polyhedron_from_base_polygon_and_extrud_vector(
Polygon(Point(0, 0, 0), Point(1, 0, 0), Point(1, 1, 0),
Point(0, 1, 0)), Vector(0, 0, 1))
self.assertEqual(ph.base_polygon_and_extrud_vector, (Polygon(
Point(0.0, 1.0, 0.0), Point(1.0, 1.0, 0.0), Point(1.0, 0.0, 0.0),
Point(0.0, 0.0, 0.0)), Vector(-0.0, -0.0, 1.0)))
def test___eq__(self):
""
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
self.assertTrue(hl==hl)
P0,vL=Point(0,0,0),Vector(1,1,1)
hl=Halfline(P0,vL)
self.assertTrue(hl==hl)
def test__intersect_line_skew_3D(self):
""
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertEqual(l._intersect_line_skew_3D(Line(P0, Vector(1, -1, 0))),
P0)
self.assertEqual(
l._intersect_line_skew_3D(Line(Point(0, 0, 1), Vector(1, -1, 0))),
None)
def test_calculate_point(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertEqual(l.calculate_point(2), P0 + vL * 2)
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertEqual(l.calculate_point(2), P0 + vL * 2)
def test___add__(self):
""
pt = Point(0, 0)
v = Vector(1, 0)
self.assertEqual(pt + v, Point(1, 0))
pt = Point(0, 0, 0)
v = Vector(1, 0, 0)
self.assertEqual(pt + v, Point(1, 0, 0))
def test___init__(self):
""
v = Vector(1, 0)
self.assertIsInstance(v, Vector)
self.assertEqual(v[0], 1)
self.assertEqual(v[1], 0)
v = Vector(1, 0, 0)
self.assertIsInstance(v, Vector)
self.assertEqual(list(v), [1.0, 0.0, 0.0])
def test_calculate_t_from_coordinates(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertEqual(l.calculate_t_from_coordinates(*(P0 + vL * 2)), 2)
self.assertEqual(l.calculate_t_from_coordinates(2, 0), 2)
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertEqual(l.calculate_t_from_coordinates(*(P0 + vL * 2)), 2)
def test_line(self):
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
self.assertEqual(hl.line,
Line(P0,vL))
P0,vL=Point(0,0,0),Vector(1,1,1)
hl=Halfline(P0,vL)
self.assertEqual(hl.line,
Line(P0,vL))
def test_cross_product(self):
""
v1 = Vector(1, 0, 0)
v2 = Vector(0, 1, 0)
self.assertEqual(v1.cross_product(v1), Vector(0, 0, 0))
self.assertEqual(v1.cross_product(v1.opposite), Vector(0, 0, 0))
self.assertEqual(v1.cross_product(v2), Vector(0, 0, 1))
def test_point_xy(self):
""
P0 = Point(0, 0, 10)
N = Vector(0, 0, 1)
pl = Plane(P0, N)
self.assertEqual(pl.point_xy(1, 1), Point(1, 1, 10))
P0 = Point(0, 0, 0)
N = Vector(0, 1, 0)
pl = Plane(P0, N)
self.assertRaises(ValueError, pl.point_xy, 1, 1)
def test_is_perpendicular(self):
""
v = Vector(1, 0)
self.assertFalse(v.is_perpendicular(v))
self.assertTrue(v.is_perpendicular(v.perp_vector))
v = Vector(1, 0, 0)
self.assertFalse(v.is_perpendicular(v))
self.assertTrue(v.is_perpendicular(Vector(0, 1, 0)))
def test___eq__(self):
""
v = Vector(0, 0)
self.assertTrue(v == v)
v1 = Vector(1, 0)
self.assertFalse(v == v1)
v2 = Vector(0, 1, 2)
self.assertRaises(ValueError, v.__eq__, v2)
v3 = (0, 0.0000000000001)
self.assertTrue(v == v3)
def test_distance_to_point(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertEqual(l.distance_to_point(P0), 0)
self.assertEqual(l.distance_to_point(P0 + vL), 0)
self.assertEqual(l.distance_to_point(P0 + vL.perp_vector), vL.length)
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertEqual(l.distance_to_point(P0), 0)
self.assertEqual(l.distance_to_point(P0 + Vector(1, -1, 0)),
Vector(1, -1, 0).length)
def test_is_parallel(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertTrue(l.is_parallel(l))
self.assertTrue(l.is_parallel(Line(P0, vL.opposite)))
self.assertTrue(l.is_parallel(Line(P0 + vL.perp_vector, vL)))
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertTrue(l.is_parallel(l))
self.assertTrue(l.is_parallel(Line(P0, vL.opposite)))
self.assertTrue(l.is_parallel(Line(P0 + Vector(1, -1, 0), vL)))
def test___contains__(self):
""
pl = Plane(P0, N)
# point
self.assertTrue(pl.contains(P0))
self.assertTrue(pl.contains(Point(10, 10, 0)))
self.assertFalse(pl.contains(Point(0, 0, 1)))
# line
self.assertTrue(pl.contains(Line(P0, Vector(1, 0, 0))))
self.assertFalse(pl.contains(Line(P0 + N, Vector(1, 0, 0))))
self.assertFalse(pl.contains(Line(P0, N)))
def test___init__(self):
""
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
self.assertIsInstance(hl,Halfline)
self.assertEqual(hl.P0,Point(0,0))
self.assertEqual(hl.vL,Vector(1,1))
P0,vL=Point(0,0,0),Vector(1,1,1)
hl=Halfline(P0,vL)
self.assertIsInstance(hl,Halfline)
self.assertEqual(hl.P0,Point(0,0,0))
self.assertEqual(hl.vL,Vector(1,1,1))
def test___sub__(self):
""
pt1 = Point(0, 0)
pt2 = Point(1, 0)
self.assertEqual(pt2 - pt1, Vector(1, 0))
v = Vector(1, 0)
self.assertEqual(pt2 - v, pt1)
pt1 = Point(0, 0, 0)
pt2 = Point(1, 0, 0)
self.assertEqual(pt2 - pt1, Vector(1, 0, 0))
v = Vector(1, 0, 0)
self.assertEqual(pt2 - v, pt1)
def test_distance_to_segment(self):
""
P0, P1 = Point(0, 0, 0), Point(1, 1, 1)
s = Segment(P0, P1)
self.assertEqual(s.distance_to_segment(s), 0)
self.assertEqual(
s.distance_to_segment(
Segment(P0 + Vector(1, -1, 0), P1 + Vector(1, -1, 0))),
Vector(1, -1, 0).length)
self.assertEqual(s.distance_to_segment(Segment(P0, Point(1, -1, 0))),
0)
self.assertEqual(
s.distance_to_segment(Segment(Point(-2, -2, -2), Point(-1, -1,
-1))),
Vector(1, 1, 1).length)
def test___init__(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertIsInstance(l, Line)
self.assertEqual(l.P0, P0)
self.assertEqual(l.vL, vL)
def test_contains(self):
""
P0, P1 = Point(0, 0), Point(1, 1)
s = Segment(P0, P1)
# point
self.assertTrue(s.contains(P0))
self.assertTrue(s.contains(P1))
self.assertTrue(s.contains(P0 + s.line.vL * 0.5)) # segment midpoint
self.assertFalse(s.contains(P0 + s.line.vL * -0.5))
self.assertFalse(s.contains(P0 + s.line.vL * 1.5))
# segment
self.assertTrue(s.contains(s))
self.assertTrue(s.contains(Segment(P0, P0 + s.line.vL * 0.5)))
self.assertTrue(s.contains(Segment(P0 + s.line.vL * 0.5, P1)))
self.assertFalse(s.contains(Segment(P0 + s.line.vL * -0.5, P1)))
self.assertFalse(s.contains(Segment(P0, P1 + s.line.vL * 0.5)))
self.assertFalse(s.contains(Segment(P0, P0 + s.line.vL.perp_vector)))
P0, P1 = Point(0, 0, 0), Point(1, 1, 1)
s = Segment(P0, P1)
# point
self.assertTrue(s.contains(P0))
self.assertTrue(s.contains(P1))
self.assertTrue(s.contains(P0 + s.line.vL * 0.5)) # segment midpoint
self.assertFalse(s.contains(P0 + s.line.vL * -0.5))
self.assertFalse(s.contains(P0 + s.line.vL * 1.5))
# segment
self.assertTrue(s.contains(s))
self.assertTrue(s.contains(Segment(P0, P0 + s.line.vL * 0.5)))
self.assertTrue(s.contains(Segment(P0 + s.line.vL * 0.5, P1)))
self.assertFalse(s.contains(Segment(P0 + s.line.vL * -0.5, P1)))
self.assertFalse(s.contains(Segment(P0, P1 + s.line.vL * 0.5)))
self.assertFalse(s.contains(Segment(P0, P0 + Vector(1, -1, 0))))
def test_intersect_halfline(self):
""
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
# same
self.assertEqual(hl.intersect_halfline(hl),
hl)
# codirectional
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL,vL)),
Halfline(P0+vL,vL))
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL*-1,vL)),
hl)
# parallel
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL.perp_vector,vL)),
None)
# collinear but not codirectinal
self.assertEqual(hl.intersect_halfline(Halfline(P0,vL*-1)),
hl.P0)
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL,vL*-1)),
Segment(P0,P0+vL))
# skew
self.assertEqual(hl.intersect_halfline(Halfline(P0,vL.perp_vector)),
hl.P0)
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL,vL.perp_vector)),
P0+vL)
self.assertEqual(hl.intersect_halfline(Halfline(P0+vL*-1,vL.perp_vector)),
None)
def test_intersect_line(self):
""
P0,vL=Point(0,0),Vector(1,1)
hl=Halfline(P0,vL)
# collinear
self.assertEqual(hl.intersect_line(Line(P0,vL)),
hl)
# parallel
self.assertEqual(hl.intersect_line(Line(Point(0,1),vL)),
None)
# skew - same P0s
self.assertEqual(hl.intersect_line(Line(P0,Vector(0,1))),
P0)
# skew - different P0s
self.assertEqual(hl.intersect_line(Line(Point(0.5,0),Vector(0,1))),
Point(0.5,0.5))
def test___eq__(self):
""
P0, vL = Point(0, 0), Vector(1, 1)
l = Line(P0, vL)
self.assertTrue(l == Line(P0, vL * 2))
self.assertTrue(l == Line(P0, vL.opposite))
self.assertTrue(l == Line(P0 + vL, vL))
self.assertFalse(l == Line(P0, vL.perp_vector))
self.assertFalse(l == Line(P0 + vL.perp_vector, vL))
P0, vL = Point(0, 0, 0), Vector(1, 1, 1)
l = Line(P0, vL)
self.assertTrue(l == Line(P0, vL * 2))
self.assertTrue(l == Line(P0, vL.opposite))
self.assertTrue(l == Line(P0 + vL, vL))
self.assertFalse(l == Line(P0, Vector(1, -1, 0)))
self.assertFalse(l == Line(P0 + Vector(1, -1, 0), vL))