def test_metadata(self):
tilestore = MBTilesTileStore(sqlite3.connect(':memory:'))
tilestore.put_one(Tile(TileCoord(1, 0, 0)))
tilestore.put_one(Tile(TileCoord(2, 0, 0)))
tilestore.set_metadata_zooms()
self.assertEqual(int(tilestore.metadata['minzoom']), 1)
self.assertEqual(int(tilestore.metadata['maxzoom']), 2)
self.assertEqual(sorted(tilestore.metadata.itervalues()), ['1', '2'])
self.assertEqual(sorted(tilestore.metadata.keys()),
['maxzoom', 'minzoom'])
def test_one(self):
tilestore = DictTileStore()
self.assertEqual(len(tilestore), 0)
tilestream = [
Tile(TileCoord(1, 0, 0), data='data'), None,
Tile(TileCoord(1, 0, 1), error=True)
]
tilestream = tilestore.put(tilestream)
tiles = list(tilestream)
self.assertEqual(len(tiles), 2)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
self.assertEqual(tiles[0].data, 'data')
self.assertEqual(tiles[1].tilecoord, TileCoord(1, 0, 1))
self.assertEqual(tiles[1].error, True)
self.assertTrue(Tile(TileCoord(1, 0, 0)) in tilestore)
self.assertTrue(Tile(TileCoord(1, 0, 1)) in tilestore)
tilestream = [Tile(TileCoord(1, 0, 0)), Tile(TileCoord(1, 0, 1))]
tilestream = tilestore.get(tilestream)
consume(tilestream, None)
tiles = list(tilestore.get_all())
self.assertEqual(len(tiles), 2)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
self.assertEqual(tiles[0].data, 'data')
self.assertEqual(tiles[1].tilecoord, TileCoord(1, 0, 1))
self.assertEqual(tiles[1].error, True)
tilestream = [Tile(TileCoord(1, 0, 0))]
tilestream = tilestore.delete(tilestream)
consume(tilestream, None)
tiles = list(tilestore.get_all())
self.assertEqual(len(tiles), 1)
self.assertFalse(Tile(TileCoord(1, 0, 0)) in tilestore)
self.assertTrue(Tile(TileCoord(1, 0, 1)) in tilestore)
def get_one(self, tile):
if not tile:
return None
test_tile = Tile(tile.tilecoord)
while test_tile.tilecoord:
if test_tile in self.tilestore:
tmp_tilecoord = tile.tilecoord
tile.tilecoord = test_tile.tilecoord
tile = self.tilestore.get_one(tile)
if tile:
tile.tilecoord = tmp_tilecoord
return tile
else:
test_tile.tilecoord = self.tilegrid.parent(test_tile.tilecoord)
return None
def get_one(self, tile):
if not tile:
return None
test_tile = Tile(tile.tilecoord)
while test_tile.tilecoord:
if test_tile in self.tilestore:
tmp_tilecoord = tile.tilecoord
tile.tilecoord = test_tile.tilecoord
tile = self.tilestore.get_one(tile)
if tile:
tile.tilecoord = tmp_tilecoord
return tile
else:
test_tile.tilecoord = self.tilegrid.parent(test_tile.tilecoord)
return None
def test_get(self):
image = Image.new('RGBA', (8, 8))
image.paste((255, 0, 0, 0), (0, 0, 4, 4))
image.paste((0, 255, 0, 0), (0, 4, 4, 8))
image.paste((0, 0, 255, 0), (4, 0, 8, 4))
image.paste((0, 0, 0, 255), (4, 4, 8, 8))
string_io = StringIO()
image.save(string_io, 'PNG')
tile = Tile(TileCoord(1, 0, 0, 2), data=string_io.getvalue())
tiles = list(self.mtsts.get([tile]))
self.assertEqual(len(tiles), 4)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
image = Image.open(StringIO(tiles[0].data))
self.assertEqual(image.size, (2, 2))
self.assertEqual(image.getcolors(), [(4, (255, 0, 0, 0))])
self.assertEqual(tiles[1].tilecoord, TileCoord(1, 0, 1))
image = Image.open(StringIO(tiles[1].data))
self.assertEqual(image.size, (2, 2))
self.assertEqual(image.getcolors(), [(4, (0, 255, 0, 0))])
self.assertEqual(tiles[2].tilecoord, TileCoord(1, 1, 0))
image = Image.open(StringIO(tiles[2].data))
self.assertEqual(image.size, (2, 2))
self.assertEqual(image.getcolors(), [(4, (0, 0, 255, 0))])
self.assertEqual(tiles[3].tilecoord, TileCoord(1, 1, 1))
image = Image.open(StringIO(tiles[3].data))
self.assertEqual(image.size, (2, 2))
self.assertEqual(image.getcolors(), [(4, (0, 0, 0, 255))])
def main(argv):
# Create our RenderingTheWorld tile store that will manage the queue and subdivision.
# We pass it the function that decides whether a tile should be subdivided, and an initial tile.
rendering_the_world_tilestore = RenderingTheWorldTileStore(subdivide, seeds=(Tile(TileCoord(0, 0, 0)),))
# Start the tilestream by getting a list of all tiles to be generated.
tilestream = rendering_the_world_tilestore.list()
tilestream = imap(Logger(logger, logging.INFO, 'get %(tilecoord)s'), tilestream)
# Create the tile store that will generate our tiles, in this case it's a demo WMTS server at OpenGeo.
# Getting tiles from this store will either return the tile as a PNG file, or set an error on the tile if there are no features in this tile.
generate_tilestore = WMTSTileStore(
url='http://v2.suite.opengeo.org/geoserver/gwc/service/wmts/',
layer='medford:buildings',
style='_null',
format='image/png',
tile_matrix_set='EPSG:900913',
tile_matrix=lambda z: 'EPSG:900913:%d' % (z,))
tilestream = generate_tilestore.get(tilestream)
tilestream = imap(Logger(logger, logging.INFO, 'got %(tilecoord)s, error=%(error)s'), tilestream)
# Put the tile back into the RenderingTheWorld tile store. This check whether the tile should be subdivided, and, if so, adds the tile's children to the list of tiles to be generated.
tilestream = rendering_the_world_tilestore.put(tilestream)
# Get rid of tiles that returned an error (i.e. where there was no data).
tilestream = imap(DropErrors(), tilestream)
# Store the generated tiles in the output tile store, in our case a local MBTiles file.
output_tilestore = MBTilesTileStore(sqlite3.connect('medford_buildings.mbtiles'))
tilestream = output_tilestore.put(tilestream)
tilestream = imap(Logger(logger, logging.INFO, 'saved %(tilecoord)s'), tilestream)
# Go!
consume(tilestream, None)
def list(self):
for x in xrange(0, self.width):
for y in xrange(0, self.height):
if self.pixels[x, y]:
yield Tile(
TileCoord(self.z, self.xbounds.start + x,
self.ybounds.stop - y - 1))
def list(self):
# FIXME warn that this consumes file
filename_re = re.compile(self.tilelayout.pattern)
for line in self.file:
match = filename_re.search(line)
if match:
yield Tile(self.tilelayout.tilecoord(match.group()), line=line)
def test_init_boundingpyramid(self):
ts = TileStore(
bounding_pyramid=BoundingPyramid.from_string('1/0/0:1/1'))
self.assertTrue(Tile(TileCoord(1, 0, 0)) in ts)
tiles = list(ts.list())
self.assertEqual(len(tiles), 1)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
def list(self):
prefix = getattr(self.tilelayout, 'prefix', '')
for s3_key in self.s3bucket.list_objects(prefix=prefix):
try:
tilecoord = self.tilelayout.tilecoord(s3_key.name)
except ValueError:
continue
yield Tile(tilecoord, s3_key=s3_key)
def test(self):
tilestore = NullTileStore()
tile = Tile(TileCoord(0, 0, 0))
self.assertFalse(tile in tilestore)
self.assertEqual(list(tilestore.delete([tile])), [tile])
self.assertEqual(list(tilestore.list()), [])
self.assertEqual(list(tilestore.get([tile])), [tile])
self.assertEqual(list(tilestore.put([tile])), [tile])
def popleft(self):
sqs_message = self.queue.read(self.visibility_timeout)
if sqs_message is None:
return self.on_empty()
z = sqs_message.get('z')
x = sqs_message.get('x')
y = sqs_message.get('y')
return Tile(TileCoord(z, x, y), sqs_message=sqs_message)
def test_empty(self):
ts = TileStore()
self.assertEqual(ts.bounding_pyramid, None)
self.assertEqual(ts.content_type, None)
self.assertEqual(len(ts), 0)
self.assertRaises(NotImplementedError, next,
ts.delete((Tile(TileCoord(0, 0, 0)), )))
self.assertRaises(NotImplementedError, ts.delete_one, None)
self.assertEqual(ts.get_cheap_bounding_pyramid(), None)
self.assertRaises(NotImplementedError, next,
ts.get((Tile(TileCoord(0, 0, 0)), )))
self.assertEqual(list(ts.get_all()), [])
self.assertRaises(NotImplementedError, ts.get_one, None)
self.assertEqual(list(ts.list()), [])
self.assertRaises(NotImplementedError, next,
ts.put((Tile(TileCoord(0, 0, 0)), )))
self.assertRaises(NotImplementedError, ts.put_one, None)
self.assertFalse(None in ts)
self.assertEqual(ts.get_bounding_pyramid(), BoundingPyramid())
def get(self, tiles):
for metatile in tiles:
metaimage = Image.open(StringIO(metatile.data))
for tilecoord in metatile.tilecoord:
x = self.border + (tilecoord.x -
metatile.tilecoord.x) * self.tile_size
y = self.border + (tilecoord.y -
metatile.tilecoord.y) * self.tile_size
image = metaimage.crop(
(x, y, x + self.tile_size, y + self.tile_size))
string_io = StringIO()
image.save(string_io, FORMAT_BY_CONTENT_TYPE[self.format])
yield Tile(tilecoord,
data=string_io.getvalue(),
content_type=self.format)
def __call__(self, tile):
image = PIL.Image.open(StringIO(tile.data))
for tilestore in self.tilestores:
t = tilestore.get_one(Tile(tile.tilecoord))
if t is not None:
image2 = PIL.Image.open(StringIO(t.data))
image.paste(image2, None, image2)
content_type = self.content_type
if content_type is None:
self.content_type = tile.content_type
string_io = StringIO()
image.save(string_io, FORMAT_BY_CONTENT_TYPE[content_type],
**self.kwargs)
tile.content_type = content_type
tile.data = string_io.getvalue()
return tile
def test_one(self):
tilestore = MBTilesTileStore(sqlite3.connect(':memory:'),
content_type='image/png')
self.assertEqual(len(tilestore), 0)
tilestream = [
Tile(TileCoord(1, 0, 0), data='data'), None,
Tile(TileCoord(1, 0, 1), error=True)
]
tilestream = tilestore.put(tilestream)
tiles = list(tilestream)
self.assertEqual(len(tilestore), 2)
self.assertEqual(len(tiles), 2)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
self.assertEqual(tiles[0].data, 'data')
self.assertEqual(tiles[1].tilecoord, TileCoord(1, 0, 1))
self.assertEqual(tiles[1].error, True)
self.assertTrue(Tile(TileCoord(1, 0, 0)) in tilestore)
self.assertTrue(Tile(TileCoord(1, 0, 1)) in tilestore)
tilestream = [Tile(TileCoord(1, 0, 0)), Tile(TileCoord(1, 0, 1))]
tilestream = tilestore.get(tilestream)
consume(tilestream, None)
self.assertEqual(tilestore.get_cheap_bounding_pyramid(),
BoundingPyramid({1: (Bounds(0, 1), Bounds(0, 2))}))
self.assertEqual(len(tilestore), 2)
tiles = list(tilestore.list())
self.assertEqual(len(tiles), 2)
tiles = sorted(tilestore.get_all())
self.assertEqual(len(tiles), 2)
self.assertEqual(tiles[0].tilecoord, TileCoord(1, 0, 0))
self.assertEqual(str(tiles[0].data), 'data')
self.assertEqual(tiles[1].tilecoord, TileCoord(1, 0, 1))
self.assertEqual(tiles[1].data, None)
tilestream = [Tile(TileCoord(1, 0, 0))]
tilestream = tilestore.delete(tilestream)
consume(tilestream, None)
self.assertEqual(len(tilestore), 1)
tiles = list(tilestore.get_all())
self.assertEqual(len(tiles), 1)
self.assertFalse(Tile(TileCoord(1, 0, 0)) in tilestore)
self.assertTrue(Tile(TileCoord(1, 0, 1)) in tilestore)
def list(self):
while True:
try:
sqs_message = self.queue.read()
if sqs_message is None:
try:
self.on_empty(self.queue)
except StopIteration:
break
else:
z = sqs_message.get('z')
x = sqs_message.get('x')
y = sqs_message.get('y')
n = sqs_message.get('n')
# FIXME deserialize other attributes
tile = Tile(TileCoord(z, x, y, n), sqs_message=sqs_message)
yield tile
except SQSDecodeError as e:
logger.warning(str(e))
sqs_message.delete()
def get_all(self):
for tilecoord, typeindex, data in self.tiles.iteritems():
tile = Tile(tilecoord, data=data)
tileformat = TileFormat.from_type_index(typeindex)
tile.content_type = tileformat.content_type
yield tile
def list(self):
for tilecoord in self.tiles.iterkeys():
yield Tile(tilecoord)
def list(self):
for mongo_tile in self.collection.find({}):
tile = Tile(TileCoord(mongo_tile["zoom_level"], mongo_tile["tile_column"], mongo_tile["tile_row"]))
yield tile
def get_all(self):
for tilecoord, typeindex, data in self.tiles.iteritems():
tile = Tile(tilecoord, data=data)
tileformat = TileFormat.from_type_index(typeindex)
tile.content_type = tileformat.content_type
yield tile
def test_empty(self):
tile = Tile(TileCoord(0, 0, 0))
self.assertEqual(tile.content_type, None)
self.assertEqual(tile.content_encoding, None)
self.assertEqual(tile.data, None)
self.assertEqual(tile.error, None)
def test_init_kwargs(self):
tile = Tile(TileCoord(0, 0, 0), kwarg=None)
self.assertEqual(tile.kwarg, None)
def test_get_one(self):
tilestore = DictTileStore()
self.assertEqual(tilestore.get_one(Tile(TileCoord(0, 0, 0))), None)
def list(self):
return imap(lambda s: Tile(TileCoord.from_string(s)),
self.db.iterkeys())
def get_all(self):
for tilecoord, data in self.tiles.iteritems():
tile = Tile(tilecoord, data=data)
if self.content_type is not None:
tile.content_type = self.content_type
yield tile
def list(self):
return (Tile(tilecoord) for tilecoord in self.tiles)
def put_one(self, tile):
if self.subdivide(tile):
for tilecoord in self.tilegrid.children(tile.tilecoord):
self.queue.append(Tile(tilecoord))
return tile
def get_all(self):
for key, data in self.db.items():
tile = Tile(TileCoord.from_string(key),
content_type=self.content_type,
data=data)
yield tile
def get_all(self):
for tilecoord, data in self.tiles.iteritems():
tile = Tile(tilecoord, data=data)
if self.content_type is not None:
tile.content_type = self.content_type
yield tile
def test_empty(self):
connection = sqlite3.connect(':memory:')
tilestore = MBTilesTileStore(connection)
self.assertEqual(len(tilestore), 0)
self.assertEqual(tilestore.get_one(Tile(TileCoord(0, 0, 0))), None)
