def setup(self):
self.tile_dir = tempfile.mkdtemp()
self.file_cache = MockFileCache(self.tile_dir,
'png',
lock_dir=tmp_lock_dir)
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.source = SlowMockSource()
self.image_opts = ImageOptions(format='image/png')
self.tile_mgr = TileManager(self.grid,
self.file_cache, [self.source],
'png',
meta_size=[2, 2],
meta_buffer=0,
image_opts=self.image_opts)
def setup(self):
self.file_cache = MockFileCache('/dev/null',
'png',
lock_dir=tmp_lock_dir)
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.source_base = MockSource()
self.source_overlay = MockSource()
self.image_opts = ImageOptions(format='image/png')
self.tile_mgr = TileManager(self.grid,
self.file_cache,
[self.source_base, self.source_overlay],
'png',
image_opts=self.image_opts)
self.layer = CacheMapLayer(self.tile_mgr)
def setup(self):
self.file_cache = MockFileCache('/dev/null',
'png',
lock_dir=tmp_lock_dir)
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockWMSClient()
self.source = WMSSource(self.client)
self.image_opts = ImageOptions(format='image/png')
self.tile_mgr = TileManager(self.grid,
self.file_cache, [self.source],
'png',
meta_size=[2, 2],
meta_buffer=0,
image_opts=self.image_opts)
def test_sources_with_no_support_for_meta_tiles(self):
self.source_base.supports_meta_tiles = False
self.source_overlay.supports_meta_tiles = False
self.locker = TileLocker(tmp_lock_dir, 10, "id")
self.tile_mgr = TileManager(self.grid,
self.file_cache,
[self.source_base, self.source_overlay],
'png',
meta_size=[2, 2],
meta_buffer=0,
locker=self.locker)
assert self.tile_mgr.meta_grid is None
def tile_mgr(self, mock_file_cache, source_base, source_overlay,
tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90], origin='ul')
return TileManager(
grid,
mock_file_cache,
[source_base, source_overlay],
'png',
meta_size=[2, 2],
meta_buffer=0,
locker=tile_locker,
bulk_meta_tiles=True,
concurrent_tile_creators=2,
)
def tile_mgr(self, mock_file_cache, tile_locker, source_base,
source_overlay):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
image_opts = ImageOptions(format='image/png')
return TileManager(
grid,
mock_file_cache,
[source_base, source_overlay],
'png',
image_opts=image_opts,
meta_size=[2, 2],
meta_buffer=0,
locker=tile_locker,
)
def tile_mgr(self, mock_file_cache, tile_locker, mock_wms_client):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
source = WMSSource(mock_wms_client)
image_opts = ImageOptions(format='image/png')
return TileManager(
grid,
mock_file_cache,
[source],
'png',
meta_size=[2, 2],
meta_buffer=0,
image_opts=image_opts,
locker=tile_locker,
)
def setup(self):
self.file_cache = MockFileCache('/dev/null', 'png')
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockTileClient()
self.source = TiledSource(self.grid, self.client)
self.image_opts = ImageOptions(format='image/png')
self.locker = TileLocker(tmp_lock_dir, 10, "id")
self.tile_mgr = TileManager(
self.grid,
self.file_cache,
[self.source],
'png',
image_opts=self.image_opts,
locker=self.locker,
)
def setup(self):
self.file_cache = MockFileCache('/dev/null',
'png',
lock_dir=tmp_lock_dir)
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.source_base = SolidColorMockSource(color='#ff0000')
self.source_base.supports_meta_tiles = True
self.source_overlay = MockSource()
self.source_overlay.supports_meta_tiles = True
self.tile_mgr = TileManager(self.grid,
self.file_cache,
[self.source_base, self.source_overlay],
'png',
meta_size=[2, 2],
meta_buffer=0)
def setup(self):
self.file_cache = MockFileCache('/dev/null', 'png')
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockWMSClient()
self.source = WMSSource(self.client)
self.locker = TileLocker(tmp_lock_dir, 10, "id")
self.tile_mgr = TileManager(
self.grid,
self.file_cache,
[self.source],
'png',
meta_size=[2, 2],
meta_buffer=10,
minimize_meta_requests=True,
locker=self.locker,
)
def test_sources_with_no_support_for_meta_tiles(self, mock_file_cache,
source_base,
source_overlay,
tile_locker):
source_base.supports_meta_tiles = False
source_overlay.supports_meta_tiles = False
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
tile_mgr = TileManager(grid,
mock_file_cache, [source_base, source_overlay],
'png',
meta_size=[2, 2],
meta_buffer=0,
locker=tile_locker)
assert tile_mgr.meta_grid is None
def setup(self):
self.file_cache = MockFileCache('/dev/null', 'png')
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockWMSClient()
self.source = WMSSource(self.client)
self.image_opts = ImageOptions(resampling='nearest')
self.locker = TileLocker(tmp_lock_dir, 10, "id")
self.tile_mgr = TileManager(self.grid,
self.file_cache, [self.source],
'png',
meta_size=[2, 2],
meta_buffer=0,
image_opts=self.image_opts,
locker=self.locker)
self.layer = CacheMapLayer(self.tile_mgr,
image_opts=default_image_opts)
def test_scaled_tiles(self, name, file_cache, tile_locker, rescale_tiles, tiles, store, expected_load, output):
res = [
1.40625, # 0
0.703125, # 1
0.3515625, # 2
0.17578125, # 3
0.087890625, # 4
0.0439453125, # 5
0.02197265625, # 6
0.010986328125, # 7
0.007, # 8 additional resolution to test unregular grids
0.0054931640625, # 9
0.00274658203125, # 10
]
grid = TileGrid(SRS(4326), origin='sw', bbox=[-180, -90, 180, 90], res=res)
image_opts = ImageOptions(format='image/png', resampling='nearest')
tm = TileManager(
grid, file_cache, [], 'png',
locker=tile_locker,
image_opts=image_opts,
rescale_tiles=rescale_tiles,
)
if store:
colors = set()
if output == "partial":
colors.add((255, 255, 255))
for i, t in enumerate(store):
color = (150+i*35, 5+i*35, 5+i*35)
colors.add(color)
tile = Tile(t, ImageSource(create_tmp_image_buf((256, 256), color=color)))
file_cache.store_tile(tile)
loaded_tiles = tm.load_tile_coords(tiles)
assert not is_blank(loaded_tiles)
assert len(loaded_tiles) == len(tiles)
got_colors = set()
for t in loaded_tiles:
got_colors.update([c for _, c in t.source.as_image().getcolors()])
assert got_colors == colors
else:
loaded_tiles = tm.load_tile_coords(tiles)
assert is_blank(loaded_tiles) == (output == "blank")
assert len(loaded_tiles.tiles) == len(tiles)
assert file_cache.stored_tiles == set(store)
assert file_cache.loaded_tiles == counting_set(expected_load)
def setup(self):
self.file_cache = MockFileCache('/dev/null',
'png',
lock_dir=tmp_lock_dir)
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockWMSClient()
self.source = WMSSource(self.client)
self.image_opts = ImageOptions(resampling='nearest', format='png')
self.tile_mgr = TileManager(self.grid,
self.file_cache, [self.source],
'png',
meta_size=[1, 1],
meta_buffer=0,
image_opts=self.image_opts)
self.layer = CacheMapLayer(self.tile_mgr,
image_opts=default_image_opts)
self.layer.extent = BBOXCoverage([0, 0, 90, 45], SRS(4326)).extent
def setup(self):
self.file_cache = MockFileCache('/dev/null', 'png')
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90], origin='ul')
self.source_base = SolidColorMockSource(color='#ff0000')
self.source_base.supports_meta_tiles = False
self.source_overlay = MockSource()
self.source_overlay.supports_meta_tiles = False
self.locker = TileLocker(tmp_lock_dir, 10, "id")
self.tile_mgr = TileManager(
self.grid,
self.file_cache,
[self.source_base, self.source_overlay],
'png',
meta_size=[2, 2],
meta_buffer=0,
locker=self.locker,
bulk_meta_tiles=True,
)
def create_tile_manager(cache,
sources,
grid,
format,
tile_filter=None,
image_opts=None,
meta_size=None,
meta_buffer=None):
pre_store_filter = [tile_filter] if tile_filter else None
mgr = TileManager(grid,
cache,
sources,
format,
meta_size=meta_size,
meta_buffer=meta_buffer,
pre_store_filter=pre_store_filter,
image_opts=image_opts)
return mgr
def test_seed_with_res_list(self):
if not load_wkt: raise SkipTest('no shapely installed')
# box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
geom = load_wkt("POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90],
res=[360/256, 360/720, 360/2000, 360/5000, 360/8000])
self.tile_mgr = TileManager(self.grid, MockCache(), [self.source], 'png')
task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
seeder.walk()
eq_(len(self.seed_pool.seeded_tiles), 5)
eq_(self.seed_pool.seeded_tiles[0], set([(0, 0)]))
eq_(self.grid.grid_sizes[1], (3, 2))
eq_(self.seed_pool.seeded_tiles[1], set([(1, 0), (1, 1), (2, 0), (2, 1)]))
eq_(self.grid.grid_sizes[2], (8, 4))
eq_(self.seed_pool.seeded_tiles[2], set([(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]))
eq_(self.grid.grid_sizes[3], (20, 10))
eq_(len(self.seed_pool.seeded_tiles[3]), 5*5+2)
def test_get_map_with_res_range(self, mock_file_cache, mock_wms_client, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
res_range = resolution_range(1000, 10)
source = WMSSource(mock_wms_client, res_range=res_range)
image_opts = ImageOptions(resampling='nearest')
tile_mgr = TileManager(grid, mock_file_cache, [source], 'png',
meta_size=[2, 2], meta_buffer=0, image_opts=image_opts,
locker=tile_locker)
layer = CacheMapLayer(tile_mgr, image_opts=default_image_opts)
with pytest.raises(BlankImage):
result = layer.get_map(MapQuery(
(-20037508.34, -20037508.34, 20037508.34, 20037508.34), (500, 500),
SRS(900913), 'png'))
assert mock_file_cache.stored_tiles == set()
result = layer.get_map(MapQuery(
(0, 0, 10000, 10000), (50, 50),
SRS(900913), 'png'))
assert mock_file_cache.stored_tiles == \
set([(512, 257, 10), (513, 256, 10), (512, 256, 10), (513, 257, 10)])
assert result.size == (50, 50)
def test_get_map_with_res_range(self):
res_range = resolution_range(1000, 10)
self.source = WMSSource(self.client, res_range=res_range)
self.tile_mgr = TileManager(self.grid, self.file_cache, [self.source], 'png',
meta_size=[2, 2], meta_buffer=0, image_opts=self.image_opts)
self.layer = CacheMapLayer(self.tile_mgr, image_opts=default_image_opts)
try:
result = self.layer.get_map(MapQuery(
(-20037508.34, -20037508.34, 20037508.34, 20037508.34), (500, 500),
SRS(900913), 'png'))
except BlankImage:
pass
else:
assert False, 'expected BlankImage exception'
eq_(self.file_cache.stored_tiles, set())
result = self.layer.get_map(MapQuery(
(0, 0, 10000, 10000), (50, 50),
SRS(900913), 'png'))
eq_(self.file_cache.stored_tiles,
set([(512, 257, 10), (513, 256, 10), (512, 256, 10), (513, 257, 10)]))
eq_(result.size, (50, 50))
def test_sources_with_mixed_support_for_meta_tiles(self):
self.source_base.supports_meta_tiles = False
self.tile_mgr = TileManager(self.grid, self.file_cache,
[self.source_base, self.source_overlay], 'png',
meta_size=[2, 2], meta_buffer=0)
def tile_mgr(self, file_cache, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
client = MockTileClient()
source = TiledSource(grid, client)
tile_mgr = TileManager(grid, file_cache, [source], 'png', locker=tile_locker)
return tile_mgr
def setup(self):
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.source = TiledSource(self.grid, None)
self.tile_mgr = TileManager(self.grid, MockCache(), [self.source], 'png')
self.seed_pool = MockSeedPool()
