nearby

quadkey/__init__.py

@@ -11,8 +11,44 @@ def __init__(self, key):
 		self.key = key 
 		self.level = len(key)
 
-	def is_parent(self, parent):
-		return self != parent and parent.key[:len(self.key)-1] == self.key
+	def children(self):
+		if self.level >= 23:
+			return []
+		return [QuadKey(self.key + str(k)) for k in [0, 1, 2, 3]]
+
+	def parent(self):
+		return QuadKey(self.key[:-1])
+
+	def nearby(self):
+		tile, level = TileSystem.quadkey_to_tile(self.key)
+		perms = [(-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1)]
+		tiles = set(map(lambda perm: (abs(tile[0]+perm[0]), abs(tile[1]+perm[1])), perms))
+		return [TileSystem.tile_to_quadkey(tile, level) for tile in tiles]
+
+	def is_ancestor(self, node):
+		"""
+			If node is ancestor of self
+			Get the difference in level
+			If not, None
+		"""
+		if self.level <= node.level or self.key[:len(node.key)] != node.key: 
+			return None
+		return self.level - node.level
+
+	def is_descendent(self, node):
+		"""
+			If node is descendent of self
+			Get the difference in level
+			If not, None
+		"""
+		return node.is_ancestor(self)
+
+	def area(self):
+		size = TileSystem.map_size(self.level)
+		LAT = 0
+		res = TileSystem.ground_resolution(LAT, self.level)
+		side = (size / 2) * res
+		return side*side
 
 	def __eq__(self, other):
 		return self.key == other.key
@@ -39,5 +75,3 @@ def from_geo(geo, level):
 		tile = TileSystem.pixel_to_tile(pixel)
 		key = TileSystem.tile_to_quadkey(tile, level)
 		return QuadKey(key) 
-
-

quadkey/tile_system.py

@@ -107,5 +107,18 @@ def tile_to_quadkey(tile, level):
 	@staticmethod
 	def quadkey_to_tile(quadkey):
 		"""Transform quadkey to tile coordinates"""
-		pass
+		tile_x, tile_y = (0,0)
+		level = len(quadkey)
+		for i in xrange(level):
+			bit = level - i
+			mask = 1 << (bit - 1)
+			if quadkey[level - bit] == '1':
+				tile_x |= mask
+			if quadkey[level - bit] == '2':
+				tile_y |= mask
+			if quadkey[level - bit] == '3':
+				tile_x |= mask
+				tile_y |= mask
+		return [(tile_x, tile_y), level]
+
 

tests/quadkey_tests.py

@@ -11,22 +11,40 @@ def testInit(self):
 		with self.assertRaises(AssertionError):
 			qk = QuadKey('0156510012')
 
-	def testFromString(self):
-		pass
-
-	def testToString(self):
-		pass
-
 	def testGetQuadKey(self):
 		geo = (40, -105)
 		level = 7 
 		key = QuadKey('0231010')
 		self.assertEqual(key, QuadKey.from_geo(geo, level))
 
-	def testGetCoordinates(self):
-		pass
+	def testEquality(self):
+		one = QuadKey('00')
+		two = QuadKey('00')
+		self.assertEqual(one, two)
+		three = QuadKey('0')
+		self.assertNotEqual(one, three)
+
+
+	def testChildren(self):
+		qk = QuadKey('0') 
+		self.assertEqual([c.key for c in qk.children()], ['00','01', '02', '03'])
+		qk = QuadKey(''.join(['0' for x in xrange(23)]))
+		self.assertEqual(qk.children(), [])
+
+	def testAncestry(self):
+		one = QuadKey('0')
+		two = QuadKey('0101')
+		self.assertEqual(3, one.is_descendent(two))
+		self.assertIsNone(two.is_descendent(one))
+		self.assertEqual(3, two.is_ancestor(one))
+		three = QuadKey('1')
+		self.assertIsNone(three.is_ancestor(one))
+
+	def testNearby(self):
+		qk = QuadKey('0')
+		self.assertEqual(set(['1','2','3']), set(qk.nearby()))
+		qk = QuadKey('01')
+		print qk
+		print qk.nearby()
+		self.assertEqual(set(['00','10','02','03',,'13','33','32','23']), set(qk.nearby()))
 
-	def testIsParent(self):
-		child = QuadKey('0011')
-		parent = QuadKey('00')
-		self.assertTrue(child.is_parent(parent))

tests/tile_system.py

@@ -26,7 +26,7 @@ def testMapScale(self):
 		geo = (40., -105.)
 		level = 7
 		dpi = 96
-		scale = 3540913.0290224822
+		scale = 3540913.0290224836
 		self.assertEqual(scale, TileSystem.map_scale(geo[0], level, dpi))
 
 	def testGeoToPixel(self):
@@ -58,4 +58,7 @@ def testTileToQuadkey(self):
 		self.assertEqual(key, TileSystem.tile_to_quadkey(tile, level))
 
 	def testQuadkeyToTile(self):
-		pass
+		tile = (26, 48)
+		level = 7
+		key = "0231010"
+		self.assertEqual([tile, level], TileSystem.quadkey_to_tile(key))