def test_auto_resolution(self):
grid = TileGrid(is_geodetic=True,
bbox=(-10, 30, 10, 40),
tile_size=(20, 20))
tile_bbox = grid.tile_bbox((0, 0, 0))
assert tile_bbox == (-10, 30, 10, 50)
assert grid.resolution(0) == 1.0
class TestWGS84TileGrid(object):
def setup(self):
self.grid = TileGrid(is_geodetic=True)
def test_resolution(self):
assert_almost_equal(self.grid.resolution(0), 1.40625)
assert_almost_equal(self.grid.resolution(1), 1.40625/2)
def test_bbox(self):
eq_(self.grid.bbox, (-180.0, -90.0, 180.0, 90.0))
def test_grid_size(self):
eq_(self.grid.grid_sizes[0], (1, 1))
eq_(self.grid.grid_sizes[1], (2, 1))
eq_(self.grid.grid_sizes[2], (4, 2))
def test_affected_tiles(self):
bbox, grid, tiles = self.grid.get_affected_tiles((-180,-90,180,90), (512,256))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(grid, (2, 1))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
def test_affected_level_tiles(self):
bbox, grid, tiles = self.grid.get_affected_level_tiles((-180,-90,180,90), 1)
eq_(grid, (2, 1))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
bbox, grid, tiles = self.grid.get_affected_level_tiles((0,0,180,90), 2)
eq_(grid, (2, 1))
eq_(bbox, (0.0, 0.0, 180.0, 90.0))
eq_(list(tiles), [(2, 1, 2), (3, 1, 2)])
def test_explicit_grid(self):
grid = TileGrid(res=[0.1, 0.05, 0.01])
eq_(grid.resolution(0), 0.1)
eq_(grid.resolution(1), 0.05)
eq_(grid.resolution(2), 0.01)
eq_(grid.closest_level(0.00001), 2)
def test_explicit_grid(self):
grid = TileGrid(res=[0.1, 0.05, 0.01])
eq_(grid.resolution(0), 0.1)
eq_(grid.resolution(1), 0.05)
eq_(grid.resolution(2), 0.01)
eq_(grid.closest_level(0.00001), 2)
class TestWGS84TileGrid(object):
def setup(self):
self.grid = TileGrid(is_geodetic=True)
def test_resolution(self):
assert_almost_equal(self.grid.resolution(0), 1.40625)
assert_almost_equal(self.grid.resolution(1), 1.40625 / 2)
def test_bbox(self):
eq_(self.grid.bbox, (-180.0, -90.0, 180.0, 90.0))
def test_grid_size(self):
eq_(self.grid.grid_sizes[0], (1, 1))
eq_(self.grid.grid_sizes[1], (2, 1))
eq_(self.grid.grid_sizes[2], (4, 2))
def test_affected_tiles(self):
bbox, grid, tiles = self.grid.get_affected_tiles((-180, -90, 180, 90),
(512, 256))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(grid, (2, 1))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
def test_affected_level_tiles(self):
bbox, grid, tiles = self.grid.get_affected_level_tiles(
(-180, -90, 180, 90), 1)
eq_(grid, (2, 1))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
bbox, grid, tiles = self.grid.get_affected_level_tiles((0, 0, 180, 90),
2)
eq_(grid, (2, 1))
eq_(bbox, (0.0, 0.0, 180.0, 90.0))
eq_(list(tiles), [(2, 1, 2), (3, 1, 2)])
def __init__(self, srs, target_dir):
self.service_srs = srs
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
def tile_mgr(self, mock_file_cache, mock_tile_client, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
source_grid = TileGrid(SRS(4326), bbox=[0, -90, 180, 90])
source = TiledSource(source_grid, mock_tile_client)
image_opts = ImageOptions(format='image/png')
return TileManager(grid, mock_file_cache, [source], 'png',
image_opts=image_opts,
locker=tile_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_grid = TileGrid(SRS(4326), bbox=[0, -90, 180, 90])
self.client = MockTileClient()
self.source = TiledSource(self.source_grid, self.client)
self.image_opts = ImageOptions(format='image/png')
self.tile_mgr = TileManager(self.grid, self.file_cache, [self.source], 'png',
image_opts=self.image_opts)
def test_broken_bbox(self):
grid = TileGrid()
# broken request from "ArcGIS Client Using WinInet"
req_bbox = (-10000855.0573254,2847125.18913603,-9329367.42767611,4239924.78564583)
try:
grid.get_affected_tiles(req_bbox, (256, 256), req_srs=SRS(31467))
except TransformationError:
pass
else:
assert False, 'Expected TransformationError'
def test_affected_tiles_out_of_grid_bounds(self):
grid = TileGrid()
#bbox from open layers
req_bbox = (-30056262.509599999, -10018754.170400001, -20037508.339999996, -0.00080000050365924835)
bbox, grid_size, tiles = \
grid.get_affected_tiles(req_bbox, (256, 256))
assert_almost_equal_bbox(bbox, req_bbox)
eq_(grid_size, (1, 1))
tiles = list(tiles)
eq_(tiles, [None])
def test_broken_bbox(self):
grid = TileGrid()
# broken request from "ArcGIS Client Using WinInet"
req_bbox = (-10000855.0573254,2847125.18913603,-9329367.42767611,4239924.78564583)
try:
grid.get_affected_tiles(req_bbox, (256, 256), req_srs=SRS(31467))
except TransformationError:
pass
else:
assert False, 'Expected TransformationError'
def test_affected_tiles_out_of_grid_bounds(self):
grid = TileGrid()
#bbox from open layers
req_bbox = (-30056262.509599999, -10018754.170400001, -20037508.339999996, -0.00080000050365924835)
bbox, grid_size, tiles = \
grid.get_affected_tiles(req_bbox, (256, 256))
assert_almost_equal_bbox(bbox, req_bbox)
eq_(grid_size, (1, 1))
tiles = list(tiles)
eq_(tiles, [None])
def __init__(self, db_session, srs, target_dir, couch_url, couch_port):
self.db_session = db_session
self.couch_url = couch_url
self.couch_port = couch_port
self.service_srs = srs
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
class TestGeodeticTileGrid(TileGridTest):
def setup(self):
self.grid = TileGrid(is_geodetic=True, )
def test_auto_resolution(self):
grid = TileGrid(is_geodetic=True,
bbox=(-10, 30, 10, 40),
tile_size=(20, 20))
tile_bbox = grid.tile_bbox((0, 0, 0))
assert tile_bbox == (-10, 30, 10, 50)
assert grid.resolution(0) == 1.0
def test_grid(self):
for level, grid_size in [(0, (1, 1)), (1, (2, 1)), (2, (4, 2))]:
yield self.check_grid, level, grid_size
def test_adjacent_tile_bbox(self):
grid = TileGrid(is_geodetic=True,
bbox=(-10, 30, 10, 40),
tile_size=(20, 20))
t1 = grid.tile_bbox((0, 0, 2))
t2 = grid.tile_bbox((1, 0, 2))
t3 = grid.tile_bbox((0, 1, 2))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[2] == t3[2]
assert t1[3] == t3[1]
def test_w_resolution(self):
res = [1, 0.5, 0.2]
grid = TileGrid(is_geodetic=True,
bbox=(-10, 30, 10, 40),
tile_size=(20, 20),
res=res)
assert grid.grid_sizes[0] == (1, 1)
assert grid.grid_sizes[1] == (2, 1)
assert grid.grid_sizes[2] == (5, 3)
def test_tile(self):
assert self.grid.tile(-180, -90, 0) == (0, 0, 0)
assert self.grid.tile(-180, -90, 1) == (0, 0, 1)
assert self.grid.tile(-180, -90, 2) == (0, 0, 2)
assert self.grid.tile(180 - 0.001, 90 - 0.001, 0) == (0, 0, 0)
assert self.grid.tile(10, 50, 1) == (1, 0, 1)
def test_affected_tiles(self):
bbox, grid_size, tiles = \
self.grid.get_affected_tiles((-45,-45,45,45), (512,512))
assert self.grid.grid_sizes[3] == (8, 4)
assert bbox == (-45.0, -45.0, 45.0, 45.0)
assert grid_size == (2, 2)
tiles = list(tiles)
assert tiles == [(3, 2, 3), (4, 2, 3), (3, 1, 3), (4, 1, 3)]
def setup(self):
self.grid = TileGrid(
SRS(31467),
bbox=[420000, 30000, 900000, 350000],
origin='ul',
res=[
4000, 3750, 3500, 3250, 3000, 2750, 2500, 2250, 2000, 1750,
1500, 1250, 1000, 750, 650, 500, 250, 100, 50, 20, 10, 5, 2.5,
2, 1.5, 1, 0.5
],
)
def test_adjacent_tile_bbox(self):
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20))
t1 = grid.tile_bbox((0, 0, 2))
t2 = grid.tile_bbox((1, 0, 2))
t3 = grid.tile_bbox((0, 1, 2))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[2] == t3[2]
assert t1[3] == t3[1]
def test_adjacent_tile_bbox(self):
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20))
t1 = grid.tile_bbox((0, 0, 2))
t2 = grid.tile_bbox((1, 0, 2))
t3 = grid.tile_bbox((0, 1, 2))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[2] == t3[2]
assert t1[3] == t3[1]
class TestClosestLevelTinyResFactor(object):
def setup(self):
self.grid = TileGrid(SRS(31467),
bbox=[420000,30000,900000,350000], origin='ul',
res=[4000,3750,3500,3250,3000,2750,2500,2250,2000,1750,1500,1250,1000,750,650,500,250,100,50,20,10,5,2.5,2,1.5,1,0.5],
)
def test_closest_level(self):
eq_(self.grid.closest_level(5000), 0)
eq_(self.grid.closest_level(4000), 0)
eq_(self.grid.closest_level(3750), 1)
eq_(self.grid.closest_level(3500), 2)
eq_(self.grid.closest_level(3250), 3)
eq_(self.grid.closest_level(3000), 4)
def test_seed_with_res_list(self):
# 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",
locker=DummyLocker())
task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
seeder.walk()
assert len(self.seed_pool.seeded_tiles) == 5
assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
assert self.grid.grid_sizes[1] == (3, 2)
assert self.seed_pool.seeded_tiles[1] == set([(1, 0), (1, 1), (2, 0),
(2, 1)])
assert self.grid.grid_sizes[2] == (8, 4)
assert self.seed_pool.seeded_tiles[2] == set([(4, 2), (5, 2), (4, 3),
(5, 3), (3, 3)])
assert self.grid.grid_sizes[3] == (20, 10)
assert len(self.seed_pool.seeded_tiles[3]) == 5 * 5 + 2
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',
locker=DummyLocker())
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_metatile_non_default_meta_size(self):
mgrid = MetaGrid(grid=TileGrid(), meta_size=(4, 2))
meta_tile = mgrid.meta_tile((4, 5, 3))
assert_almost_equal_bbox(
meta_tile.bbox, (0.0, 0.0, 20037508.342789244, 10018754.171394622))
eq_(meta_tile.size, (1024, 512))
eq_(meta_tile.grid_size, (4, 2))
def test_metagrid_tiles_w_meta_size():
mgrid = MetaGrid(grid=TileGrid(), meta_size=(4, 2))
assert list(mgrid.meta_tile((1, 2, 2)).tile_patterns) == \
[((0, 3, 2), (0, 0)), ((1, 3, 2), (256, 0)),
((2, 3, 2), (512, 0)), ((3, 3, 2), (768, 0)),
((0, 2, 2), (0, 256)), ((1, 2, 2), (256, 256)),
((2, 2, 2), (512, 256)), ((3, 2, 2), (768, 256))]
def __init__(self, srs, target_dir):
self.service_srs = srs
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
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.tile_mgr = TileManager(self.grid, self.file_cache, [self.source], 'png',
meta_size=[2, 2], meta_buffer=10, minimize_meta_requests=True)
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_bad_config_geopackage_no_gpkg_contents(self, app, base_dir):
gpkg_file = base_dir.join("cache.gpkg").strpath
table_name = "no_gpkg_contents"
with sqlite3.connect(gpkg_file) as db:
cur = db.execute(
"""SELECT name FROM sqlite_master WHERE type='table' AND name=?""",
(table_name, ),
)
content = cur.fetchone()
assert content[0] == table_name
with sqlite3.connect(gpkg_file) as db:
cur = db.execute(
"""SELECT table_name FROM gpkg_contents WHERE table_name=?""",
(table_name, ),
)
content = cur.fetchone()
assert not content
GeopackageCache(gpkg_file, TileGrid(srs=4326), table_name=table_name)
with sqlite3.connect(gpkg_file) as db:
cur = db.execute(
"""SELECT table_name FROM gpkg_contents WHERE table_name=?""",
(table_name, ),
)
content = cur.fetchone()
assert content[0] == table_name
def tile_mgr(self, mock_file_cache, mock_wms_client, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
source = WMSSource(mock_wms_client)
return TileManager(grid, mock_file_cache, [source], 'png',
meta_size=[2, 2], meta_buffer=10, minimize_meta_requests=True,
locker=tile_locker,
)
def setup(self):
self.cache_dir = tempfile.mkdtemp()
self.file_cache = FileCache(cache_dir=self.cache_dir, file_ext='png')
self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
self.client = MockTileClient()
self.source = TiledSource(self.grid, self.client)
self.tile_mgr = TileManager(self.grid, self.file_cache, [self.source], 'png')
def tile_mgr(self, file_cache, slow_source, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
image_opts = ImageOptions(format='image/png')
return TileManager(grid, file_cache, [slow_source], 'png',
meta_size=[2, 2], meta_buffer=0, image_opts=image_opts,
locker=tile_locker,
)
class TestGeodeticTileGrid(TileGridTest):
def setup(self):
self.grid = TileGrid(is_geodetic=True, )
def test_auto_resolution(self):
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20))
tile_bbox = grid.tile_bbox((0, 0, 0))
assert tile_bbox == (-10, 30, 10, 50)
assert grid.resolution(0) == 1.0
def test_grid(self):
for level, grid_size in [(0, (1, 1)), (1, (2, 1)), (2, (4, 2))]:
yield self.check_grid, level, grid_size
def test_adjacent_tile_bbox(self):
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20))
t1 = grid.tile_bbox((0, 0, 2))
t2 = grid.tile_bbox((1, 0, 2))
t3 = grid.tile_bbox((0, 1, 2))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[2] == t3[2]
assert t1[3] == t3[1]
def test_w_resolution(self):
res = [1, 0.5, 0.2]
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20), res=res)
assert grid.grid_sizes[0] == (1, 1)
assert grid.grid_sizes[1] == (2, 1)
assert grid.grid_sizes[2] == (5, 3)
def test_tile(self):
assert self.grid.tile(-180, -90, 0) == (0, 0, 0)
assert self.grid.tile(-180, -90, 1) == (0, 0, 1)
assert self.grid.tile(-180, -90, 2) == (0, 0, 2)
assert self.grid.tile(180-0.001, 90-0.001, 0) == (0, 0, 0)
assert self.grid.tile(10, 50, 1) == (1, 0, 1)
def test_affected_tiles(self):
bbox, grid_size, tiles = \
self.grid.get_affected_tiles((-45,-45,45,45), (512,512))
assert self.grid.grid_sizes[3] == (8, 4)
assert bbox == (-45.0, -45.0, 45.0, 45.0)
assert grid_size == (2, 2)
tiles = list(tiles)
assert tiles == [(3, 2, 3), (4, 2, 3), (3, 1, 3), (4, 1, 3)]
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",
locker=DummyLocker())
self.seed_pool = MockSeedPool()
def layer(self, mock_file_cache, mock_wms_client, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
source = WMSSource(mock_wms_client)
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)
return CacheMapLayer(tile_mgr, image_opts=default_image_opts)
def test_metatile_bbox(self):
mgrid = MetaGrid(grid=TileGrid(), meta_size=(2, 2))
meta_tile = mgrid.meta_tile((0, 0, 2))
assert meta_tile.bbox == (-20037508.342789244, -20037508.342789244, 0.0, 0.0)
meta_tile = mgrid.meta_tile((1, 1, 2))
assert meta_tile.bbox == (-20037508.342789244, -20037508.342789244, 0.0, 0.0)
meta_tile = mgrid.meta_tile((4, 5, 3))
assert_almost_equal_bbox(meta_tile.bbox, (0.0, 0.0, 10018754.171394622, 10018754.171394622))
def tile_mgr(self, file_cache, tile_locker):
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
client = MockTileClient()
source = TiledSource(grid, client)
image_opts = ImageOptions(format='image/png')
return TileManager(grid, file_cache, [source], 'png',
image_opts=image_opts,
locker=tile_locker)
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,
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 test_sources_with_mixed_support_for_meta_tiles(self, mock_file_cache, source_base, source_overlay, tile_locker):
source_base.supports_meta_tiles = False
grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
with pytest.raises(ValueError):
TileManager(grid, file_cache,
[source_base, source_overlay], 'png',
meta_size=[2, 2], meta_buffer=0,
locker=tile_locker)
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,
)
def __init__(self, db_session, srs, target_dir, couchdb_url, template_dir):
self.db_session = db_session
self.couchdb_url = couchdb_url
self.service_srs = srs
self.template_dir = template_dir
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
class TestFixedResolutionsTileGrid(TileGridTest):
def setup(self):
self.res = [1000.0, 500.0, 200.0, 100.0, 50.0, 20.0, 5.0]
bbox = (3250000, 5230000, 3930000, 6110000)
self.grid = TileGrid(SRS(31467), bbox=bbox, res=self.res)
def test_resolution(self):
for level, res in enumerate(self.res):
assert res == self.grid.resolution(level)
def test_closest_level(self):
assert self.grid.closest_level(2000) == 0
assert self.grid.closest_level(1000) == 0
assert self.grid.closest_level(950) == 0
assert self.grid.closest_level(210) == 2
def test_affected_tiles(self):
req_bbox = (3250000, 5230000, 3930000, 6110000)
self.grid.max_shrink_factor = 10
bbox, grid_size, tiles = \
self.grid.get_affected_tiles(req_bbox, (256, 256))
assert bbox == (req_bbox[0], req_bbox[1],
req_bbox[0]+1000*256*3, req_bbox[1]+1000*256*4)
assert grid_size == (3, 4)
tiles = list(tiles)
assert tiles == [(0, 3, 0), (1, 3, 0), (2, 3, 0),
(0, 2, 0), (1, 2, 0), (2, 2, 0),
(0, 1, 0), (1, 1, 0), (2, 1, 0),
(0, 0, 0), (1, 0, 0), (2, 0, 0),
]
def test_affected_tiles_2(self):
req_bbox = (3250000, 5230000, 3930000, 6110000)
self.grid.max_shrink_factor = 2.0
try:
bbox, grid_size, tiles = \
self.grid.get_affected_tiles(req_bbox, (256, 256))
except NoTiles:
pass
else:
assert False, 'got no exception'
def test_grid(self):
for level, grid_size in [(0, (3, 4)), (1, (6, 7)), (2, (14, 18))]:
yield self.check_grid, level, grid_size
def test_tile_bbox(self):
tile_bbox = self.grid.tile_bbox((0, 0, 0)) # w: 1000x256
assert tile_bbox == (3250000.0, 5230000.0, 3506000.0, 5486000.0)
tile_bbox = self.grid.tile_bbox((0, 0, 1)) # w: 500x256
assert tile_bbox == (3250000.0, 5230000.0, 3378000.0, 5358000.0)
tile_bbox = self.grid.tile_bbox((0, 0, 2)) # w: 200x256
assert tile_bbox == (3250000.0, 5230000.0, 3301200.0, 5281200.0)
def test_above_first_res(self):
grid = TileGrid(res=[1000, 500, 250, 100, 50], threshold_res=[1100, 750])
grid.stretch_factor = 1.1
eq_(grid.closest_level(1200), 0)
eq_(grid.closest_level(1100), 0)
eq_(grid.closest_level(1000), 0)
eq_(grid.closest_level(800), 0)
eq_(grid.closest_level(750.1), 0)
eq_(grid.closest_level(750), 1)
def test_lower_bound(self):
# thresholds near the next lower res value
grid = TileGrid(res=[1000, 500, 250, 100, 50], threshold_res=[300, 110])
grid.stretch_factor = 1.1
eq_(grid.closest_level(1100), 0)
# regular transition (w/stretchfactor)
eq_(grid.closest_level(950), 0)
eq_(grid.closest_level(800), 1)
eq_(grid.closest_level(500), 1)
# transition at threshold
eq_(grid.closest_level(301), 1)
eq_(grid.closest_level(300), 2)
eq_(grid.closest_level(250), 2)
# transition at threshold
eq_(grid.closest_level(111), 2)
eq_(grid.closest_level(110), 3)
eq_(grid.closest_level(100), 3)
# regular transition (w/stretchfactor)
eq_(grid.closest_level(92), 3)
eq_(grid.closest_level(90), 4)
def test_upper_bound(self):
# thresholds near the next upper res value (within threshold)
grid = TileGrid(res=[1000, 500, 250, 100, 50], threshold_res=[495, 240])
grid.stretch_factor = 1.1
eq_(grid.closest_level(1100), 0)
# regular transition (w/stretchfactor)
eq_(grid.closest_level(950), 0)
eq_(grid.closest_level(800), 1)
eq_(grid.closest_level(500), 1)
# transition at threshold
eq_(grid.closest_level(496), 1)
eq_(grid.closest_level(495), 2)
eq_(grid.closest_level(250), 2)
# transition at threshold (within strechfactor)
eq_(grid.closest_level(241), 2)
eq_(grid.closest_level(240), 3)
eq_(grid.closest_level(100), 3)
# regular transition (w/stretchfactor)
eq_(grid.closest_level(92), 3)
eq_(grid.closest_level(90), 4)
class TestGKTileGrid(TileGridTest):
def setup(self):
self.grid = TileGrid(SRS(31467), bbox=(3250000, 5230000, 3930000, 6110000))
def test_bbox(self):
assert self.grid.bbox == (3250000, 5230000, 3930000, 6110000)
def test_resolution(self):
res = self.grid.resolution(0)
width = self.grid.bbox[2] - self.grid.bbox[0]
height = self.grid.bbox[3] - self.grid.bbox[1]
assert height == 880000.0 and width == 680000.0
assert res == 880000.0/256
def test_tile_bbox(self):
tile_bbox = self.grid.tile_bbox((0, 0, 0))
assert tile_bbox == (3250000.0, 5230000.0, 4130000.0, 6110000.0)
def test_tile(self):
x, y = 3450000, 5890000
assert [self.grid.tile(x, y, level) for level in range(5)] == \
[(0, 0, 0), (0, 1, 1), (0, 3, 2), (1, 6, 3), (3, 12, 4)]
def test_grids(self):
for level, grid_size in [(0, (1, 1)), (1, (2, 2)), (2, (4, 4)), (3, (7, 8))]:
yield self.check_grid, level, grid_size
def test_closest_level(self):
assert self.grid.closest_level(880000.0/256) == 0
assert self.grid.closest_level(600000.0/256) == 1
assert self.grid.closest_level(440000.0/256) == 1
assert self.grid.closest_level(420000.0/256) == 1
def test_adjacent_tile_bbox(self):
t1 = self.grid.tile_bbox((0, 0, 1))
t2 = self.grid.tile_bbox((1, 0, 1))
t3 = self.grid.tile_bbox((0, 1, 1))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[3] == t3[1]
def setup(self):
self.grid = TileGrid(SRS(31467),
bbox=[420000,30000,900000,350000], origin='ul',
res=[4000,3750,3500,3250,3000,2750,2500,2250,2000,1750,1500,1250,1000,750,650,500,250,100,50,20,10,5,2.5,2,1.5,1,0.5],
)
def setup(self):
self.grid = TileGrid(SRS(31467),
bbox=(3300000, 5300000, 3900000, 6000000), origin='ul',
res=[1500, 1000, 500, 300, 150, 100])
class TestGKTileGridUL(TileGridTest):
"""
Custom grid with ul origin.
"""
def setup(self):
self.grid = TileGrid(SRS(31467),
bbox=(3300000, 5300000, 3900000, 6000000), origin='ul',
res=[1500, 1000, 500, 300, 150, 100])
def test_bbox(self):
assert self.grid.bbox == (3300000, 5300000, 3900000, 6000000)
def test_tile_bbox(self):
eq_(self.grid.tile_bbox((0, 0, 0)),
(3300000.0, 5616000.0, 3684000.0, 6000000.0))
eq_(self.grid.tile_bbox((1, 0, 0)),
(3684000.0, 5616000.0, 4068000.0, 6000000.0))
eq_(self.grid.tile_bbox((1, 1, 0)),
(3684000.0, 5232000.0, 4068000.0, 5616000.0))
def test_tile(self):
x, y = 3310000, 5990000
eq_(self.grid.tile(x, y, 0), (0, 0, 0))
eq_(self.grid.tile(x, y, 1), (0, 0, 1))
eq_(self.grid.tile(x, y, 2), (0, 0, 2))
x, y = 3890000, 5310000
eq_(self.grid.tile(x, y, 0), (1, 1, 0))
eq_(self.grid.tile(x, y, 1), (2, 2, 1))
eq_(self.grid.tile(x, y, 2), (4, 5, 2))
def test_grids(self):
assert_grid_size(self.grid, 0, (2, 2))
assert_grid_size(self.grid, 1, (3, 3))
assert_grid_size(self.grid, 2, (5, 6))
def test_closest_level(self):
assert self.grid.closest_level(1500) == 0
assert self.grid.closest_level(1000) == 1
assert self.grid.closest_level(900) == 1
assert self.grid.closest_level(600) == 2
def test_adjacent_tile_bbox(self):
t1 = self.grid.tile_bbox((0, 0, 1))
t2 = self.grid.tile_bbox((1, 0, 1))
t3 = self.grid.tile_bbox((0, 1, 1))
assert t1[1] == t2[1]
assert t1[3] == t2[3]
assert t1[2] == t2[0]
assert t1[0] == t3[0]
assert t1[1] == t3[3]
def test_sqrt_grid(self):
grid = TileGrid(is_geodetic=True, res='sqrt2', tile_size=(360, 180))
eq_(grid.resolution(0), 1.0)
assert_almost_equal(grid.resolution(2), 0.5)
assert_almost_equal(grid.resolution(4), 0.25)
def setup(self):
self.res = [1000.0, 500.0, 200.0, 100.0, 50.0, 20.0, 5.0]
bbox = (3250000, 5230000, 3930000, 6110000)
self.grid = TileGrid(SRS(31467), bbox=bbox, res=self.res)
def setup(self):
self.grid = TileGrid(4326, bbox=(-180, -90, 180, 90), origin='ul')
class TestWGS83TileGridUL(object):
def setup(self):
self.grid = TileGrid(4326, bbox=(-180, -90, 180, 90), origin='ul')
def test_resolution(self):
assert_almost_equal(self.grid.resolution(0), 1.40625)
assert_almost_equal(self.grid.resolution(1), 1.40625/2)
def test_bbox(self):
eq_(self.grid.bbox, (-180.0, -90.0, 180.0, 90.0))
def test_tile_bbox(self):
eq_(self.grid.tile_bbox((0, 0, 0)), (-180.0, -270.0, 180.0, 90.0))
eq_(self.grid.tile_bbox((0, 0, 0), limit=True), (-180.0, -90.0, 180.0, 90.0))
eq_(self.grid.tile_bbox((0, 0, 1)), (-180.0, -90.0, 0.0, 90.0))
def test_tile(self):
eq_(self.grid.tile(-170, -80, 0), (0, 0, 0))
eq_(self.grid.tile(-170, -80, 1), (0, 0, 1))
eq_(self.grid.tile(-170, -80, 2), (0, 1, 2))
def test_grid_size(self):
eq_(self.grid.grid_sizes[0], (1, 1))
eq_(self.grid.grid_sizes[1], (2, 1))
eq_(self.grid.grid_sizes[2], (4, 2))
def test_affected_tiles(self):
bbox, grid, tiles = self.grid.get_affected_tiles((-180,-90,180,90), (512,256))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(grid, (2, 1))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
bbox, grid, tiles = self.grid.get_affected_tiles((-180,-90,0,90), (512, 512))
eq_(bbox, (-180.0, -90.0, 0.0, 90.0))
eq_(grid, (2, 2))
eq_(list(tiles), [(0, 0, 2), (1, 0, 2), (0, 1, 2), (1, 1, 2)])
def test_affected_level_tiles(self):
bbox, grid, tiles = self.grid.get_affected_level_tiles((-180,-90,180,90), 1)
eq_(grid, (2, 1))
eq_(bbox, (-180.0, -90.0, 180.0, 90.0))
eq_(list(tiles), [(0, 0, 1), (1, 0, 1)])
bbox, grid, tiles = self.grid.get_affected_level_tiles((0,0,180,90), 2)
eq_(grid, (2, 1))
eq_(list(tiles), [(2, 0, 2), (3, 0, 2)])
eq_(bbox, (0.0, 0.0, 180.0, 90.0))
bbox, grid, tiles = self.grid.get_affected_level_tiles((0,-90,180,90), 2)
eq_(grid, (2, 2))
eq_(list(tiles), [(2, 0, 2), (3, 0, 2), (2, 1, 2), (3, 1, 2)])
eq_(bbox, (0.0, -90.0, 180.0, 90.0))
def setup(self):
self.grid = TileGrid(is_geodetic=True, )
def test_auto_resolution(self):
grid = TileGrid(is_geodetic=True, bbox=(-10, 30, 10, 40), tile_size=(20, 20))
tile_bbox = grid.tile_bbox((0, 0, 0))
assert tile_bbox == (-10, 30, 10, 50)
assert grid.resolution(0) == 1.0
class MapProxyConfiguration(object):
def __init__(self, db_session, srs, target_dir, couchdb_url, template_dir):
self.db_session = db_session
self.couchdb_url = couchdb_url
self.service_srs = srs
self.template_dir = template_dir
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
def _load_sources(self):
local_sources = self.db_session.query(LocalWMTSSource).all()
for local_source in local_sources:
wmts_source = local_source.wmts_source
self.sources[wmts_source.name + '_source'] = {
'type': 'wms',
'req': {
'url': 'http://dummy.example.org/service?'
},
'seed_only': True,
'coverage': {
'srs': 'EPSG:3857',
'bbox': list(coverage_from_geojson(wmts_source.download_coverage).bbox)
}
}
self.caches[wmts_source.name + '_cache'] = {
'sources': [wmts_source.name + '_source'],
'grids': [wmts_source.matrix_set],
'cache': {
'type': 'couchdb',
'url': '%s' % self.couchdb_url,
'db_name': wmts_source.name,
'tile_metadata': {
'tile_col': '{{x}}',
'tile_row': '{{y}}',
'tile_level': '{{z}}',
'created_ts': '{{timestamp}}',
'created': '{{utc_iso}}',
'center': '{{wgs_tile_centroid}}'
}
}
}
self.layers.append({
'name': wmts_source.name + '_layer',
'title': wmts_source.title,
'sources': [wmts_source.name + '_cache'],
'min_res': self.grid.resolution(local_source.download_level_start),
# increase max_res to allow a bit of oversampling
'max_res': self.grid.resolution(local_source.download_level_end) / 2,
})
def _write_mapproxy_yaml(self):
grids = {
'GoogleMapsCompatible': {
'base': 'GLOBAL_MERCATOR',
'srs': 'EPSG:3857',
'num_levels': 19,
'origin': 'nw'
}
}
services = {
'demo': None,
'wmts': None,
'wms': {
'srs': self.service_srs,
'md': {'title': 'Geobox WMS'}
},
}
globals_ = {
'image': {
'paletted': True,
},
'cache': {
'meta_size': [8, 8],
'meta_buffer': 50,
},
'http': {
'client_timeout': 120,
},
}
if self.template_dir:
globals_['template_dir'] = self.template_dir
config = {}
if globals_: config['globals'] = globals_
if grids: config['grids'] = grids
if self.layers:
config['layers'] = self.layers
config['services'] = services
if self.caches: config['caches'] = self.caches
if self.sources: config['sources'] = self.sources
# safe_dump does not output !!python/unicode, etc.
mapproxy_yaml = yaml.safe_dump(config, default_flow_style=False)
f = open(self.yaml_file, 'w')
f.write(mapproxy_yaml)
f.close()
log.info('Mapproxy configuration written to %s', self.yaml_file)
def test_factor_grid(self):
grid = TileGrid(is_geodetic=True, res=1/0.75, tile_size=(360, 180))
eq_(grid.resolution(0), 1.0)
eq_(grid.resolution(1), 0.75)
eq_(grid.resolution(2), 0.75*0.75)
def setup(self):
self.grid = TileGrid(SRS(31467), bbox=(3250000, 5230000, 3930000, 6110000))
def test_tile_out_of_grid_bounds(self):
grid = TileGrid(is_geodetic=True)
eq_(grid.tile(-180.01, 50, 1), (-1, 0, 1))
class MapProxyConfiguration(object):
def __init__(self, srs, target_dir):
self.service_srs = srs
self.sources = {}
self.caches = {}
self.layers = []
self.yaml_file = os.path.join(target_dir, 'mapproxy.yaml')
self.grid = TileGrid(SRS(3857))
def _load_sources(self):
public_wmts = db.session.query(WMTS, ST_Transform(WMTS.view_coverage, 3857)).filter_by(is_public=True).group_by(WMTS).all()
for wmts, view_coverage in public_wmts:
self.sources['%s_source' % wmts.name] = {
'type': 'tile',
'url': wmts.url,
'grid': 'GoogleMapsCompatible',
'coverage': {
'srs': 'EPSG:3857',
'bbox': list(to_shape(view_coverage).bounds)
}
}
self.caches['%s_cache' % wmts.name] = {
'sources': ['%s_source' % wmts.name],
'grids': ['GoogleMapsCompatible'],
'disable_storage': True
}
self.layers.append({
'name': '%s_layer' % wmts.name,
'title': wmts.title,
'sources': ['%s_cache' % wmts.name],
'min_res': self.grid.resolution(wmts.view_level_start),
# increase max_res to allow a bit of oversampling
'max_res': self.grid.resolution(wmts.view_level_end) / 2,
})
def _write_mapproxy_yaml(self):
grids = {
'GoogleMapsCompatible': {
'base': 'GLOBAL_MERCATOR',
'srs': 'EPSG:3857',
'num_levels': 20,
'origin': 'nw'
}
}
services = {
'demo': None,
'wms': {
'srs': self.service_srs,
'md': {'title': _('external_wms_title')}
},
}
globals_ = {
'image': {
'paletted': True,
},
'cache': {
'meta_size': [8, 8],
'meta_buffer': 50,
},
'http': {
'client_timeout': 120,
},
}
config = {}
if globals_: config['globals'] = globals_
if grids: config['grids'] = grids
if self.layers:
config['layers'] = self.layers
config['services'] = services
if self.caches: config['caches'] = self.caches
if self.sources: config['sources'] = self.sources
# safe_dump does not output !!python/unicode, etc.
mapproxy_yaml = yaml.safe_dump(config, default_flow_style=False)
f = open(self.yaml_file, 'w')
f.write(mapproxy_yaml)
f.close()
