def test_Cell_init(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Should set the rdggs, suid, and resolution attributes correctly.
suid = (S, 0, 1, 2, 6, 3, 1)
resolution = 6
C = Cell(rdggs, suid)
self.assertEqual(C.rdggs, rdggs)
self.assertEqual(C.suid, suid)
self.assertEqual(C.resolution, resolution)
# Should not create invalid cells.
suid = (P, rdggs.N_side ** 2)
self.assertRaises(AssertionError, Cell, rdggs, suid)
# Should create cell P1.
expect = (P, 1)
i = 25
get = Cell(rdggs, level_order_index=i).suid
self.assertEqual(get, expect)
expect = (P, 1)
def num(k):
return rdggs.num_cells(res_1=k, subcells=True)
i = 2 * num(0) + 1 * num(1) + num(1) - 1
get = Cell(rdggs, post_order_index=i).suid
self.assertEqual(get, expect)
def test_ne(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
A = Cell(rdggs, (O, 1, 2, 3))
AA = Cell(rdggs, (O, 1, 2, 3))
B = Cell(rdggs, (N, 2, 8, 7, 5))
self.assertFalse(A != AA)
self.assertTrue(A != B)
def test_subcells(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
l = 6
C = Cell(rdggs, (S, 1, 0, 5, 7, 7, 3))
s = list(C.subcells(l + 1))
t = [Cell(rdggs, list(C.suid) + [i]) for i in range(9)]
for i in range(9):
self.assertTrue(s[i] == t[i])
def test_gt(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
a = Cell(rdggs, (N, 7, 6, 8, 1))
b = Cell(rdggs, (O, 1, 2, 3))
c = Cell(rdggs, (O, 1, 2))
self.assertFalse(a > b)
self.assertFalse(a > c)
self.assertFalse(a > a)
self.assertTrue(b > a)
self.assertTrue(c > a)
def test_lt(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
a = Cell(rdggs, (N, 7, 6, 8, 1))
b = Cell(rdggs, (O, 1, 2, 3))
c = Cell(rdggs, (O, 1, 2))
self.assertTrue(a < b)
self.assertTrue(a < c)
self.assertFalse(a < a)
self.assertFalse(b < a)
self.assertFalse(c < a)
def test_ge(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
a = Cell(rdggs, (N, 7, 6, 8, 1))
b = Cell(rdggs, (O, 1, 2, 3))
bb = Cell(rdggs, (O, 1, 2, 3))
c = Cell(rdggs, (O, 1, 2))
self.assertTrue(b >= bb)
self.assertTrue(bb >= a)
self.assertFalse(a >= b)
self.assertFalse(a >= c)
self.assertTrue(b >= a)
self.assertTrue(c >= a)
def test_suid_rowcol(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Should work for resolution 0 cells.
for suid in CELLS0:
self.assertEqual(suid, Cell(rdggs, (suid,)).suid_rowcol()[0][0])
self.assertEqual(suid, Cell(rdggs, (suid,)).suid_rowcol()[1][0])
# Should work on an arbitrary cell.
n = rdggs.N_side
c = Cell(rdggs, (N, 1, 3, n ** 2 - 1, 2 * n))
row, col = c.suid_rowcol()
for i in range(1, c.resolution + 1):
self.assertEqual(c.suid[i], n * row[i] + col[i])
def test_nucleus(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Nuclei of children should be in correct position
# relative to parent cell in rHEALPix projection.
a = Cell(rdggs, (S, 7, 4, 1, 2, 1)) # Arbitrary cell.
w = a.width()
(x, y) = a.ul_vertex()
error = 1e-10
for (row, col) in product(list(range(3)), repeat=2):
s = str(row * 3 + col)
# Child cell in (row, column) position relative to a:
b = Cell(rdggs, list(a.suid) + [3 * row + col])
get = b.nucleus()
expect = (x + w / 6 + (w / 3) * col, y - w / 6 - (w / 3) * row)
self.assertTrue(rel_err(get, expect) < error)
def calculate_neighbours(zone_id):
if zone_id == "Earth":
return None
else:
c = Cell(TB16Pix, _suid_from_string(zone_id))
neighbours = []
for k, v in sorted(c.neighbors().items()):
neighbours.append((k, str(v)))
return neighbours
def test_random_point(self):
# Output should lie in the cell at least.
for E in [WGS84_ASPHERE_RADIANS, WGS84_ELLIPSOID]:
rdggs = RHEALPixDGGS(E)
for plane in [True, False]:
c = Cell(rdggs, [N, 8, 7])
p = c.random_point(plane=plane)
self.assertTrue(
c.contains(p, plane=plane)
) # ------------------------------------------------------------------------------
def test_contains(self):
for rdggs in [WGS84_003, WGS84_003_RADIANS]:
# A cell should contain its nucleus, but not my test point p.
# Assume that nucleus() and vertices() work.
for suid in [[N, 3, 1], [P, 5, 7, 5, 1, 3], [S, 0]]:
c = Cell(rdggs, suid)
w = c.width()
for plane in [True, False]:
nucleus = c.nucleus(plane=plane)
vertices = c.vertices(plane=plane)
p = (max([v[0] for v in vertices]) + 1, vertices[3][1])
self.assertTrue(c.contains(nucleus, plane=plane))
self.assertFalse(c.contains(p, plane=plane))
def test_index(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Empty cell should have index None
empty = rdggs.cell()
self.assertEqual(empty.index(order="level"), None)
self.assertEqual(empty.index(order="post"), None)
# Test order='level'.
# A cell should have index one greater than its predecessor
# at the same resolution.
c = rdggs.cell((N, 2, 7, 4, 8))
b = c.predecessor()
self.assertEqual(c.index(order="level"), b.index(order="level") + 1)
# It should invert suid_from_index().
M = rdggs.num_cells(0, rdggs.max_resolution)
k = 3616048 # randint(0, M - 1)
get = Cell(rdggs, Cell.suid_from_index(rdggs, k, order="level")).index(
order="level"
)
self.assertEqual(get, k)
# Test order='post'.
# The cell N00...0 should have index 0.
suid = [N] + [0] * rdggs.max_resolution
a = Cell(rdggs, suid)
self.assertEqual(a.index(order="post"), 0)
# A cell should have index one greater than its last child.
cc = list(c.subcells())[8]
self.assertEqual(c.index(order="post"), cc.index(order="post") + 1)
# It should invert suid_from_index().
k = 3616048 # randint(0, M - 1)
get = Cell(rdggs, Cell.suid_from_index(rdggs, k, order="post")).index(
order="post"
)
self.assertEqual(get, k)
def test_rotate_entry(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
X = Cell(rdggs, (N,))
# Should return correct values.
s = [] # Function values.
t = [] # Correct values.
for q in range(4):
s.append([X.rotate_entry(x, q) for x in range(9)])
t.append([0, 1, 2, 3, 4, 5, 6, 7, 8])
t.append([2, 5, 8, 1, 4, 7, 0, 3, 6])
t.append([8, 7, 6, 5, 4, 3, 2, 1, 0])
t.append([6, 3, 0, 7, 4, 1, 8, 5, 2])
for q in range(4):
self.assertEqual(s[q], t[q])
def test_ul_vertex(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Should work for resolution 0 cells.
for X in rdggs.grid(0):
get = X.ul_vertex()
expect = rdggs.ul_vertex[X.suid[0]]
self.assertEqual(get, expect)
for X in rdggs.grid(0):
get = X.ul_vertex(plane=False)
p = rdggs.ul_vertex[X.suid[0]]
expect = rdggs.rhealpix(*p, inverse=True)
self.assertEqual(get, expect)
# Should work on children cells.
a = Cell(rdggs, (S, 2, 3))
l = a.resolution
x, y = a.ul_vertex()
w = rdggs.cell_width(l + 1)
error = 1e-10 # Error tolerance.
for (i, j) in product(list(range(3)), repeat=2):
b = Cell(rdggs, list(a.suid) + [i + 3 * j])
xx, yy = b.ul_vertex()
xp, yp = (x + i * w, y - j * w)
self.assertTrue(rel_err([xx, yy], [xp, yp]) < error)
a = Cell(rdggs, (S, 2, 3))
l = a.resolution
x, y = a.ul_vertex()
w = rdggs.cell_width(l + 1)
error = rdggs.ellipsoid.R_A * 1e-15 # Error tolerance.
for (i, j) in product(list(range(3)), repeat=2):
b = Cell(rdggs, list(a.suid) + [i + 3 * j])
xx, yy = b.ul_vertex(plane=False)
xp, yp = rdggs.rhealpix(x + i * w, y - j * w, inverse=True)
self.assertTrue(rel_err([xx, yy], [xp, yp]) < error)
def test_predecessor(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
A = Cell(rdggs, (O, 0, 1))
Ap0 = Cell(rdggs, (N,))
Ap1 = Cell(rdggs, (N, 8))
Ap2 = Cell(rdggs, (O, 0, 0))
Ap3 = Cell(rdggs, (O, 0, 1, 8))
self.assertTrue(A.predecessor(0) == Ap0)
self.assertTrue(A.predecessor(1) == Ap1)
self.assertTrue(A.predecessor(2) == Ap2)
self.assertTrue(A.predecessor(3) == Ap3)
A = Cell(rdggs, (N, 0, 0))
self.assertTrue(A.predecessor(1) == None)
def test_successor(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
A = Cell(rdggs, (N, 8, 1))
As0 = Cell(rdggs, (O,))
As1 = Cell(rdggs, (O, 0))
As2 = Cell(rdggs, (N, 8, 2))
As3 = Cell(rdggs, (N, 8, 2, 0))
self.assertTrue(A.successor(0) == As0)
self.assertTrue(A.successor(1) == As1)
self.assertTrue(A.successor(2) == As2)
self.assertTrue(A.successor(3) == As3)
A = Cell(rdggs, (S, 8, 8))
self.assertTrue(A.successor(1) == None)
def _get_finest_cell(polygon, suid):
parent_cell = Cell(suid=suid)
# get the children cells and polygons for these cells
children_cells = [cell for cell in parent_cell.subcells()]
children_poly = [
Polygon(cell.vertices(plane=False)) for cell in children_cells
]
# function and truth list for multipolygon / polygon (polygon) contained within multipolygon / polygon (cell)
truth = [poly.contains(polygon) for poly in children_poly]
# if we get something back, check the next level lower
returned_cells = list(compress(children_cells, truth))
if returned_cells:
finest = _get_finest_cell(polygon, returned_cells[0].suid)
else:
parent_poly = Polygon(parent_cell.vertices(plane=False))
if parent_poly.contains(polygon):
finest = parent_cell
else:
finest = None
return finest
def test_neighbor(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
# Plane test.
c = Cell(rdggs, (N, 0))
get = c.neighbor("left")
expect = Cell(rdggs, (O, 0))
self.assertEqual(get, expect)
# Ellipsoid test.
c = Cell(rdggs, (O, 0))
get = c.neighbor("east", plane=False)
expect = Cell(rdggs, (O, 1))
self.assertEqual(get, expect)
c = Cell(rdggs, (N, 6, 4))
get = c.neighbor("south_west", plane=False)
expect = Cell(rdggs, (N, 6, 3))
self.assertEqual(get, expect)
c = Cell(rdggs, (P, 2, 2))
get = c.neighbor("north", plane=False)
expect = Cell(rdggs, (N, 8, 8))
self.assertEqual(get, expect)
def test_subcell(self):
for rdggs in [WGS84_123, WGS84_123_RADIANS]:
C = Cell(rdggs, (S, 1, 2, 0))
D = Cell(rdggs, (S, 1, 2, 0, 5))
self.assertTrue(D.subcell(C))
self.assertFalse(C.subcell(D))
def test_neighbors(self):
for rdggs in [WGS84_003, WGS84_003_RADIANS]:
# Plane test.
# Should work on resolution 1 cells with suids of the form s0
get = []
for s in CELLS0:
nb = Cell(rdggs, [s] + [0]).neighbors()
for d in ["up", "left", "down", "right"]:
get.append(nb[d])
expect = [
(Q, 2),
(R, 0),
(N, 3),
(N, 1),
(N, 6),
(R, 2),
(O, 3),
(O, 1),
(N, 8),
(O, 2),
(P, 3),
(P, 1),
(N, 2),
(P, 2),
(Q, 3),
(Q, 1),
(N, 0),
(Q, 2),
(R, 3),
(R, 1),
(O, 6),
(R, 8),
(S, 3),
(S, 1),
]
expect = [Cell(rdggs, s) for s in expect]
for i in range(len(expect)):
self.assertEqual(get[i], expect[i])
# Ellipsoid test.
# Quad.
c = Cell(rdggs, (O, 0))
get = c.neighbors(plane=False)
expect = dict()
expect["north"] = Cell(rdggs, (N, 6))
expect["south"] = Cell(rdggs, (O, 3))
expect["west"] = Cell(rdggs, (R, 2))
expect["east"] = Cell(rdggs, (O, 1))
for k in list(get.keys()):
self.assertEqual(get[k], expect[k])
# Cap.
c = Cell(rdggs, (S, 4))
get = c.neighbors(plane=False)
expect = dict()
expect["north_0"] = Cell(rdggs, (S, 1))
expect["north_1"] = Cell(rdggs, (S, 5))
expect["north_2"] = Cell(rdggs, (S, 7))
expect["north_3"] = Cell(rdggs, (S, 3))
for k in list(get.keys()):
self.assertEqual(get[k], expect[k])
# Dart.
c = Cell(rdggs, (N, 6))
get = c.neighbors(plane=False)
expect = dict()
expect["west"] = Cell(rdggs, (N, 3))
expect["east"] = Cell(rdggs, (N, 7))
expect["south_west"] = Cell(rdggs, (R, 2))
expect["south_east"] = Cell(rdggs, (O, 0))
for k in list(get.keys()):
self.assertEqual(get[k], expect[k])
# Skew quad.
c = Cell(rdggs, (N, 3))
get = c.neighbors(plane=False)
expect = dict()
expect["north"] = Cell(rdggs, (N, 4))
expect["south"] = Cell(rdggs, (R, 1))
expect["west"] = Cell(rdggs, (N, 0))
expect["east"] = Cell(rdggs, (N, 6))
for k in list(get.keys()):
self.assertEqual(get[k], expect[k])