def testContains(self):
# box-box containment
b1 = g.SphericalBox((10.0, 0.0), (20.0, 10.0))
self.assertTrue(b1.contains(b1))
b2 = g.SphericalBox((11.0, 0.0), (19.0, 10.0))
self.assertTrue(b1.contains(b2))
self.assertFalse(b2.contains(b1))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((355.0, 0.0), (365.0, 10.0))
self.assertTrue(b1.contains(b2))
self.assertFalse(b2.contains(b1))
b2 = g.SphericalBox((355.0, 0.0), (359.0, 10.0))
self.assertTrue(b1.contains(b2))
self.assertFalse(b2.contains(b1))
b2 = g.SphericalBox((0.0, 0.0), (5.0, 10.0))
self.assertTrue(b1.contains(b2))
self.assertFalse(b2.contains(b1))
# box-point containment
b = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
self.assertTrue(b.contains(b.getMin()))
self.assertTrue(b.contains(b.getMax()))
self.assertTrue(b.contains(b.getCenter()))
b = g.SphericalBox((350.0, 0.0), (370.0, 1.0))
self.assertTrue(b.contains(b.getMin()))
self.assertTrue(b.contains(b.getMax()))
self.assertTrue(b.contains(b.getCenter()))
self.assertTrue(b.contains((360.0, 0.5)))
self.assertTrue(b.contains((720.0, 0.5)))
self.assertTrue(b.contains((5.0, 0.5)))
self.assertTrue(b.contains((355.0, 0.5)))
def testInit(self):
b = g.SphericalBox()
self.assertTrue(b.isEmpty())
self.assertFalse(b.isFull())
b = g.SphericalBox((0.0, -90.0), (360.0, 90.0))
self.assertTrue(b.isFull())
self.assertFalse(b.isEmpty())
b = g.SphericalBox((-10.0, 0.0), (10.0, 0.0))
self.assertEqual(b, g.SphericalBox((350.0, 0.0), (10.0, 0.0)))
self.assertEqual(b, g.SphericalBox((350.0, 0.0), (370.0, 0.0)))
self.assertRaises(RuntimeError, g.SphericalBox, (350.0, 0.0),
(-10.0, 0.0))
self.assertRaises(RuntimeError, g.SphericalBox, (390.0, 0.0),
(-10.0, 0.0))
def testSpatialPredicates(self):
# polygon-point, polygon-circle
p = g.SphericalConvexPolygon(_pointsOnCircle((0.0, 0.0), 1.0, 8))
self.assertTrue(p.contains(p.getBoundingCircle().getCenter()))
self.assertTrue(p.intersects(p.getBoundingCircle().getCenter()))
points = _pointsOnCircle((0.0, 0.0), 0.5, 50)
for v in points:
self.assertTrue(p.contains(v))
self.assertTrue(p.intersects(v))
c = g.SphericalCircle((0.0, 0.0), 0.5)
self.assertTrue(p.contains(c))
self.assertTrue(p.intersects(c))
self.assertFalse(c.contains(p))
self.assertTrue(c.intersects(p))
points = _pointsOnCircle((0.0, 0.0), 1.001, 50)
for v in points:
self.assertFalse(p.contains(v))
self.assertFalse(p.intersects(v))
c = g.SphericalCircle((0.0, 0.0), 1.001)
c2 = g.SphericalCircle((180.0, 0.0), 1.001)
self.assertTrue(c.contains(p))
self.assertTrue(c.intersects(p))
self.assertFalse(c2.intersects(p))
self.assertFalse(p.intersects(c2))
self.assertFalse(c2.contains(p))
self.assertFalse(p.contains(c2))
self.assertFalse(p.contains(c))
self.assertTrue(p.intersects(c))
# polygon-box
b = g.SphericalBox((-0.5, -0.5), (0.5, 0.5))
self.assertTrue(b.intersects(p))
self.assertTrue(p.intersects(b))
self.assertTrue(p.contains(b))
self.assertFalse(b.contains(p))
b = g.SphericalBox((0.5, -0.5), (359.5, 0.5))
self.assertTrue(b.intersects(p))
self.assertTrue(p.intersects(b))
self.assertFalse(b.contains(p))
self.assertFalse(p.contains(b))
# polygon-polygon
self.assertTrue(p.intersects(p))
p2 = g.SphericalConvexPolygon(_pointsOnCircle((0.5, 0.0), 1.0, 8))
self.assertTrue(p.intersects(p2))
self.assertTrue(p2.intersects(p))
self.assertFalse(p.contains(p2))
self.assertFalse(p2.contains(p))
p3 = g.SphericalConvexPolygon(_pointsOnCircle((0.25, 0.0), 0.25, 8))
self.assertTrue(p.contains(p3))
def testSpatialPredicates(self):
# ellipse-point
for cen in ((0.0, 0.0), (45.0, 45.0), (135.0, -45.0), (0.0, 90.0)):
smaa = random.uniform(30, 20000)
smia = random.uniform(1, smaa)
a = random.uniform(0.0, 360.0)
e = g.SphericalEllipse(cen, smaa, smia, a)
self.assertTrue(e.contains(cen))
self.assertTrue(e.contains(g.cartesianUnitVector(cen)))
self.assertTrue(e.intersects(cen))
self.assertTrue(e.intersects(g.cartesianUnitVector(cen)))
points = _pointsOnCircle(
cen,
e.getInnerCircle().getRadius() - g.ANGLE_EPSILON, 100)
for p in points:
self.assertTrue(e.contains(p))
points = _pointsOnCircle(
cen,
e.getBoundingCircle().getRadius() + g.ANGLE_EPSILON, 100)
for p in points:
self.assertFalse(e.intersects(p))
points = _pointsOnEllipse(
cen, smaa - g.ANGLE_EPSILON * g.ARCSEC_PER_DEG,
smia - g.ANGLE_EPSILON * g.ARCSEC_PER_DEG, a, 100)
for p in points:
self.assertTrue(e.contains(p))
points = _pointsOnEllipse(
cen, smaa + g.ANGLE_EPSILON * g.ARCSEC_PER_DEG,
smia + g.ANGLE_EPSILON * g.ARCSEC_PER_DEG, a, 100)
for p in points:
self.assertFalse(e.contains(p))
# ellipse-circle
cen = (0.0, 0.0)
e = g.SphericalEllipse(cen, 7200.0, 3600.0, 90.0)
c = g.SphericalCircle(cen,
e.getInnerCircle().getRadius() - g.ANGLE_EPSILON)
self.assertTrue(e.intersects(c))
self.assertTrue(c.intersects(e))
self.assertTrue(e.contains(c))
self.assertFalse(c.contains(e))
# ellipse-box
b = g.SphericalBox((-0.5, -0.5), (0.5, 0.5))
self.assertTrue(e.intersects(b))
self.assertTrue(e.contains(b))
b = g.SphericalBox((0.5, -0.5), (359.5, 0.5))
self.assertTrue(e.intersects(b))
self.assertFalse(e.contains(b))
def testSpatialPredicates(self):
# circle-circle, circle-box, box-circle
c1 = g.SphericalCircle((0.0, 0.0), 1.0)
self.assertTrue(c1.intersects(c1))
self.assertTrue(c1.contains(c1))
b1 = c1.getBoundingBox()
self.assertTrue(b1.contains(c1))
self.assertTrue(b1.intersects(c1))
c2 = g.SphericalCircle((3.0, 0.0), 1.0)
b2 = c2.getBoundingBox()
self.assertTrue(b2.contains(c2))
self.assertTrue(b2.intersects(c2))
self.assertFalse(c1.contains(c2))
self.assertFalse(c1.intersects(c2))
c1 = g.SphericalCircle((0.0, 0.0), 5.0)
c3 = g.SphericalCircle((180.0, 0.0), 5.0)
b1 = c1.getBoundingBox()
self.assertTrue(c1.contains(c2))
self.assertFalse(c2.contains(c1))
self.assertTrue(c1.intersects(c2))
self.assertTrue(c2.intersects(c1))
self.assertTrue(b2.intersects(c1))
self.assertTrue(b2.intersects(c2))
self.assertTrue(b1.intersects(c1))
self.assertTrue(b1.intersects(c2))
self.assertFalse(c3.intersects(b1))
self.assertFalse(b1.intersects(c3))
self.assertFalse(c3.contains(b1))
self.assertFalse(b1.contains(c3))
b3 = g.SphericalBox((1.0, -1.0), (359.0, 1.0))
self.assertTrue(b3.intersects(c1))
self.assertTrue(b3.intersects(c2))
self.assertTrue(b3.contains(c2))
self.assertFalse(b3.contains(c1))
self.assertFalse(c1.contains(b3))
self.assertFalse(c2.contains(b3))
# circle-point
self.assertTrue(c1.contains((1.0, 0.0, 0.0)))
self.assertTrue(c1.intersects((0.0, 0.0)))
self.assertFalse(c1.intersects((10.0, 0.0)))
self.assertFalse(c1.contains((-10.0, 0.0)))
points = _pointsOnCircle((0.0, 0.0), 4.999, 100)
for p in points:
self.assertTrue(c1.contains(p))
points = _pointsOnCircle((0.0, 0.0), 5.001, 100)
for p in points:
self.assertFalse(c1.contains(p))
# circle-polygon
p1 = g.SphericalConvexPolygon(_pointsOnCircle((0.0, 0.0), 10.0, 100))
p2 = g.SphericalConvexPolygon(_pointsOnCircle((0.0, 0.0), 3.0, 100))
self.assertTrue(c1.contains(p2))
self.assertTrue(c1.intersects(p2))
self.assertFalse(c1.contains(p1))
self.assertTrue(c1.intersects(p2))
self.assertTrue(p1.intersects(c1))
self.assertTrue(p2.intersects(c1))
self.assertTrue(p1.contains(c1))
self.assertFalse(p2.contains(c1))
def testIntersects(self):
# box-box intersection
b1 = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
self.assertTrue(b1.intersects(b1))
b2 = g.SphericalBox((0.0, 20.0), (20.0, 25.0))
self.assertFalse(b1.intersects(b2))
b2 = g.SphericalBox((0.0, -20.0), (20.0, -5.0))
self.assertFalse(b1.intersects(b2))
b2 = g.SphericalBox((30.0, 0.0), (40.0, 25.0))
self.assertFalse(b1.intersects(b2))
b2 = g.SphericalBox((350.0, 0.0), (359.0, 25.0))
self.assertFalse(b1.intersects(b2))
b2 = g.SphericalBox((0.0, 10.0), (20.0, 25.0))
self.assertTrue(b1.intersects(b2))
b2 = g.SphericalBox((10.0, 10.0), (20.0, 25.0))
self.assertTrue(b1.intersects(b2))
b2 = g.SphericalBox((350.0, -10.0), (360.0, 0.0))
self.assertTrue(b1.intersects(b2))
b2 = g.SphericalBox((-10.0, -10.0), (5.0, 0.0))
self.assertTrue(b1.intersects(b2))
b1 = g.SphericalBox((-5.0, -5.0), (1.0, 5.0))
self.assertTrue(b1.intersects(b2))
def testMaxAlpha(self):
c = (0.0, 0.0)
for r in (1.0, 10.0, 20.0, 45.0):
for phi in (-40.0, -20.0, 0.0, 10.0, 40.0):
a = g.maxAlpha(r, phi) + g.ANGLE_EPSILON
for x in (phi, phi + r, phi - r):
self.assertTrue(g.sphericalAngularSep((a, x), c) > r)
self.assertTrue(g.sphericalAngularSep((-a, x), c) > r)
points = _pointsOnCircle((0.0, phi), r, 50)
box = g.SphericalBox((-a, phi - r - g.ANGLE_EPSILON),
(a, phi + r + +g.ANGLE_EPSILON))
for p in points:
self.assertTrue(box.contains(p))
def testIntersect(self):
pmap = g.SphericalBoxPartitionMap(1, 1)
b = g.SphericalBox((0.0, -90.0), (360.0, 90.0))
for chunkId, subIter in pmap.intersect(b):
self.assertEqual(chunkId, 0)
for subChunkId, regions in subIter:
self.assertEqual(subChunkId, 0)
self.assertEqual(regions, set())
pmap = g.SphericalBoxPartitionMap(18, 10)
b = g.SphericalBox((0.01, 0.01), (0.99, 0.99))
for chunkId, subIter in pmap.intersect(b):
self.assertEqual(chunkId, 324)
for subChunkId, regions in subIter:
self.assertEqual(subChunkId, 0)
self.assertEqual(len(regions), 1)
self.assertTrue(b in regions)
# Test with an assortment of regions
regions = [
g.SphericalBox((-0.01, -0.01), (11.0, 11.0)),
g.SphericalBox((350.0, 80.0), (360.0, 90.0)),
g.SphericalBox((350.0, -90.0), (360.0, -80.0)),
g.SphericalBox((-5.0, 20.0), (5.0, 22.0)),
g.SphericalBox((0.0, -25.0), (2.0, -20.0)),
g.SphericalCircle((45.0, 45.0), 1.0),
g.SphericalConvexPolygon((-1.0, 0.0, 0.0), (0.0, 1.0, 0.0),
g.normalize((-1.0, 1.0, -1.0))),
]
# compute expected results by brute force
results = {}
for chunkId, subIter in pmap:
for subChunkId in subIter:
bbox = pmap.getSubChunkBoundingBox(chunkId, subChunkId)
for i in xrange(len(regions)):
if regions[i].contains(bbox):
results[(chunkId, subChunkId)] = set()
break
elif regions[i].intersects(bbox):
if (chunkId, subChunkId) not in results:
results[(chunkId, subChunkId)] = set()
results[(chunkId, subChunkId)].add(regions[i])
# and compare them to the results of intersect()
for chunkId, subIter in pmap.intersect(regions):
for subChunkId, xr in subIter:
exr = results.pop((chunkId, subChunkId), None)
self.assertEqual(xr, exr)
self.assertEqual(len(results), 0)
def testExtend(self):
# box-box extension
b1 = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
b2 = g.SphericalBox((10.0, 10.0), (20.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((0.0, 0.0), (20.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((10.0, 10.0), (20.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((350.0, 0.0), (380.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((340.0, 10.0), (350.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((340.0, 0.0), (370.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((5.0, 10.0), (355.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((0.0, 0.0), (360.0, 20.0)))
b1 = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
b2 = g.SphericalBox((20.0, 10.0), (30.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((0.0, 0.0), (30.0, 20.0)))
b1 = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
b2 = g.SphericalBox((350.0, 10.0), (360.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((350.0, 0.0), (370.0, 20.0)))
b1 = g.SphericalBox((5.0, 0.0), (10.0, 10.0))
b2 = g.SphericalBox((350.0, 10.0), (355.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((350.0, 0.0), (370.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((340.0, 10.0), (375.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((340.0, 0.0), (375.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((330.0, 10.0), (340.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((330.0, 0.0), (370.0, 20.0)))
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((20.0, 10.0), (30.0, 20.0))
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((350.0, 0.0), (390.0, 20.0)))
b1 = g.SphericalBox()
b2 = g.SphericalBox()
b1.extend(b2)
self.assertTrue(b1.isEmpty())
b2.setFull()
b1.extend(b2)
self.assertTrue(b1.isFull())
b1.extend(b2)
self.assertTrue(b1.isFull())
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2.setEmpty()
b1.extend(b2)
self.assertEqual(b1, g.SphericalBox((350.0, 0.0), (370.0, 10.0)))
# box-point extension
b = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
b.extend((20.0, 20.0))
self.assertEqual(b, g.SphericalBox((0.0, 0.0), (20.0, 20.0)))
b.extend((350.0, 15.0))
self.assertEqual(b, g.SphericalBox((350.0, 0.0), (380.0, 20.0)))
self.assertRaises(RuntimeError, g.SphericalBox.extend, b, (0.0, 100.0))
self.assertRaises(RuntimeError, g.SphericalBox.extend, b,
(0.0, -100.0))
def testShrink(self):
b1 = g.SphericalBox((0.0, 0.0), (10.0, 10.0))
b2 = g.SphericalBox((10.0, 10.0), (20.0, 20.0))
self.assertFalse(b1.contains(b2))
self.assertTrue(b1.intersects(b2))
b1.shrink(b2)
self.assertEqual(b1, g.SphericalBox((10.0, 10.0), (10.0, 10.0)))
b1 = g.SphericalBox((0.0, 0.0), (15.0, 10.0))
b1.shrink(b2)
self.assertFalse(b1.contains(b2))
self.assertEqual(b1, g.SphericalBox((10.0, 10.0), (15.0, 10.0)))
b1 = g.SphericalBox((0.0, 0.0), (10.0, 9.0))
self.assertFalse(b1.contains(b2))
self.assertFalse(b1.intersects(b2))
self.assertTrue(b1.shrink(b2).isEmpty())
b1 = g.SphericalBox((0.0, 0.0), (9.0, 15.0))
self.assertFalse(b1.contains(b2))
self.assertFalse(b1.intersects(b2))
self.assertTrue(b1.shrink(b2).isEmpty())
b1 = g.SphericalBox((350.0, 0.0), (370.0, 10.0))
b2 = g.SphericalBox((5.0, 10.0), (355.0, 20.0))
b1.shrink(b2)
self.assertFalse(b1.contains(b2))
self.assertTrue(b1.intersects(b2))
self.assertEqual(b1, g.SphericalBox((350.0, 10.0), (370.0, 10.0)))
b1 = g.SphericalBox((190.0, 0.0), (540.0, 10.0))
b2 = g.SphericalBox((180.0, 10.0), (190.0, 20.0))
b1.shrink(b2)
self.assertFalse(b1.contains(b2))
self.assertTrue(b1.intersects(b2))
self.assertEqual(b1, g.SphericalBox((180.0, 10.0), (190.0, 10.0)))