def testPickle(self):
a = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
b = pickle.loads(pickle.dumps(a, pickle.HIGHEST_PROTOCOL))
self.assertEqual(a, b)
def testRelationships(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertTrue(p.contains(p.getCentroid()))
self.assertEqual(p.getBoundingCircle().relate(p), CONTAINS)
def test_construction(self):
self.assertTrue(Circle.empty().isEmpty())
self.assertTrue(Circle().isEmpty())
self.assertTrue(Circle.full().isFull())
c = Circle(UnitVector3d.X())
self.assertEqual(c.getOpeningAngle(), Angle(0))
self.assertEqual(c.getSquaredChordLength(), 0)
c = Circle(UnitVector3d.Z(), 2.0)
self.assertTrue(c.contains(UnitVector3d.Z()))
c = Circle(UnitVector3d.Z(), Angle(math.pi))
self.assertTrue(c.isFull())
d = c.clone()
self.assertEqual(c, d)
self.assertNotEqual(id(c), id(d))
e = Circle(d)
self.assertEqual(d, e)
def testYaml(self):
a = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
b = yaml.safe_load(yaml.dump(a))
self.assertEqual(a, b)
def testCodec(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
s = p.encode()
self.assertEqual(ConvexPolygon.decode(s), p)
self.assertEqual(Region.decode(s), p)
def testConstruction(self):
points = [UnitVector3d.Z(), UnitVector3d.X(), UnitVector3d.Y()]
p1 = ConvexPolygon(points)
self.assertEqual(points, p1.getVertices())
p2 = p1.clone()
self.assertEqual(p1, p2)
p3 = ConvexPolygon(
[-UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertNotEqual(p1, p3)
p4 = ConvexPolygon.convexHull([
UnitVector3d.Y(),
UnitVector3d.X(),
UnitVector3d(1, 1, 1),
UnitVector3d.Z()
])
self.assertEqual(p1, p4)
def test_string(self):
c = Circle(UnitVector3d.Z(), Angle(1.0))
self.assertEqual(str(c), 'Circle([0.0, 0.0, 1.0], 1.0)')
self.assertEqual(repr(c),
'Circle(UnitVector3d(0.0, 0.0, 1.0), Angle(1.0))')
self.assertEqual(
c,
eval(repr(c),
dict(Angle=Angle, Circle=Circle, UnitVector3d=UnitVector3d)))
def testArithmeticOperators(self):
self.assertEqual(-UnitVector3d.X(), UnitVector3d(-1, 0, 0))
self.assertEqual(UnitVector3d.X() - UnitVector3d.X(),
Vector3d(0, 0, 0))
self.assertEqual(UnitVector3d.X() + UnitVector3d(1, 0, 0),
UnitVector3d.X() * 2)
self.assertEqual(UnitVector3d.Y() - Vector3d(0, 0.5, 0),
UnitVector3d.Y() / 2)
self.assertEqual(UnitVector3d.Z().cwiseProduct(Vector3d(2, 3, 4)),
Vector3d(0, 0, 4))
def test_string(self):
c = Ellipse(UnitVector3d.Z(), Angle(1.0))
self.assertEqual(str(c),
'Ellipse([0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 1.0)')
self.assertEqual(
repr(c), 'Ellipse(UnitVector3d(0.0, 0.0, 1.0), '
'UnitVector3d(0.0, 0.0, 1.0), Angle(1.0))')
self.assertEqual(
c,
eval(repr(c),
dict(Angle=Angle, Ellipse=Ellipse,
UnitVector3d=UnitVector3d)))
def testString(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertEqual(str(p), repr(p))
self.assertEqual(
repr(p), 'ConvexPolygon([UnitVector3d(0.0, 0.0, 1.0), '
'UnitVector3d(1.0, 0.0, 0.0), '
'UnitVector3d(0.0, 1.0, 0.0)])')
self.assertEqual(
p,
eval(repr(p),
dict(ConvexPolygon=ConvexPolygon, UnitVector3d=UnitVector3d)))
def test_expanding_and_clipping(self):
a = Circle.empty()
b = (a.expandedTo(UnitVector3d.X()).expandedTo(
Circle(UnitVector3d.Y(),
1)).clippedTo(Circle(UnitVector3d(1, 1, 0),
1)).clippedTo(UnitVector3d.Y()))
a.expandTo(UnitVector3d.X())
a.expandTo(Circle(UnitVector3d.Y(), 1))
a.clipTo(Circle(UnitVector3d(1, 1, 0), 1))
a.clipTo(UnitVector3d.Y())
self.assertEqual(a, b)
self.assertEqual(a, Circle(UnitVector3d.Y()))
a.clipTo(UnitVector3d.Z())
self.assertTrue(a.isEmpty())
def testRelationships(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertTrue(p.contains(p.getCentroid()))
boundingCircle = p.getBoundingCircle()
self.assertEqual(boundingCircle.relate(p), CONTAINS)
self.assertTrue(p.isWithin(boundingCircle))
self.assertTrue(p.intersects(boundingCircle))
self.assertFalse(p.isDisjointFrom(boundingCircle))
self.assertFalse(p.contains(boundingCircle))
tinyCircle = Circle(boundingCircle.getCenter())
self.assertFalse(p.isWithin(tinyCircle))
self.assertTrue(p.intersects(tinyCircle))
self.assertFalse(p.isDisjointFrom(tinyCircle))
self.assertTrue(p.contains(tinyCircle))
def testConstruction(self):
a1 = NormalizedAngle(1.0)
a2 = NormalizedAngle.fromRadians(1.0)
a3 = NormalizedAngle.fromDegrees(57.29577951308232)
self.assertEqual(a1, a2)
self.assertEqual(a1.asRadians(), 1.0)
self.assertEqual(a1, a3)
self.assertEqual(a1.asDegrees(), 57.29577951308232)
self.assertEqual(
NormalizedAngle.between(NormalizedAngle(0), NormalizedAngle(1)),
NormalizedAngle(1))
a = NormalizedAngle.center(NormalizedAngle(0), NormalizedAngle(1))
self.assertAlmostEqual(a.asRadians(), 0.5, places=15)
a = NormalizedAngle(LonLat.fromDegrees(45, 0),
LonLat.fromDegrees(90, 0))
self.assertAlmostEqual(a.asDegrees(), 45.0, places=13)
a = NormalizedAngle(UnitVector3d.Y(), UnitVector3d.Z())
self.assertAlmostEqual(a.asDegrees(), 90.0, places=13)
def testDot(self):
self.assertEqual(UnitVector3d.X().dot(UnitVector3d.Z()), 0)
def testComparison(self):
self.assertEqual(UnitVector3d.X(), UnitVector3d.X())
self.assertNotEqual(UnitVector3d.Y(), UnitVector3d.Z())
def test_comparison_operators(self):
c = Circle(UnitVector3d.X(), 4.0)
d = Circle(UnitVector3d.Y(), 4.0)
self.assertEqual(c, d)
self.assertTrue(c.isFull())
self.assertNotEqual(c, Circle(UnitVector3d.Z()))
