def setUp(self) -> None:
self.ftg = FreeTileGrid(
resolutions=(4000, 2000, 1000, 500),
max_extent=(420000, 30000, 900000, 350000),
tile_size=100,
scale=100,
)
def vector_tiles(self) -> Response:
settings = self.request.registry.settings["vector_tiles"]
grid = FreeTileGrid(settings["resolutions"],
max_extent=settings["extent"],
tile_size=256)
layer_name = self.request.matchdict["layer_name"]
z = int(self.request.matchdict["z"])
x = int(self.request.matchdict["x"])
y = int(self.request.matchdict["y"])
coord = TileCoord(z, x, y)
minx, miny, maxx, maxy = grid.extent(coord, 0)
layer = (DBSession.query(main.LayerVectorTiles.sql).filter(
main.LayerVectorTiles.name == layer_name).one_or_none())
if layer is None:
raise HTTPNotFound(
f"Not found any vector tile layer named {layer_name}")
raw_sql = layer[0].format(
envelope=
f"ST_MakeEnvelope({minx}, {miny}, {maxx}, {maxy}, {settings['srid']})"
)
result = DBSession.execute(raw_sql)
for row in result:
set_common_headers(self.request, "vector_tiles", Cache.PUBLIC)
response = self.request.response
response.content_type = "application/vnd.mapbox-vector-tile"
response.body = row[0].tobytes()
return response
def setUp(self):
self.ftg = FreeTileGrid(resolutions=(2, 1),
max_extent=(420000, 30000, 900000, 350000),
tile_size=100,
scale=200)
self.ftg2 = FreeTileGrid(resolutions=(2, 1),
max_extent=(420000, 30000, 900000, 350000),
tile_size=256,
scale=10)
class TestFreeTileGridFlipY(unittest.TestCase):
def setUp(self):
self.ftsn = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125)
self.ftsf = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125, flip_y=True)
def test_flip_y(self):
assert self.ftsn.extent(TileCoord(2, 0, 0)) == self.ftsf.extent(TileCoord(2, 0, 3))
assert self.ftsn.extent(TileCoord(2, 1, 1)) == self.ftsf.extent(TileCoord(2, 1, 2))
assert self.ftsn.extent(TileCoord(2, 2, 2)) == self.ftsf.extent(TileCoord(2, 2, 1))
assert self.ftsn.extent(TileCoord(2, 3, 3)) == self.ftsf.extent(TileCoord(2, 3, 0))
class TestFreeTileGridWithFloatResolutions(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(resolutions=(10, 5, 2.5),
max_extent=(420000, 30000, 900000, 350000),
tile_size=100)
def test_extent(self):
assert self.ftg.extent(TileCoord(0, 0, 0)) == (420000.0, 349000.0,
421000.0, 350000.0)
assert self.ftg.extent(TileCoord(2, 0, 0)) == (420000.0, 349750.0,
420250.0, 350000.0)
class TestFreeTileGridFlipY(unittest.TestCase):
def setUp(self):
self.ftsn = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125)
self.ftsf = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125, flip_y=True)
def test_flip_y(self):
self.assertEqual(self.ftsn.extent(TileCoord(2, 0, 0)), self.ftsf.extent(TileCoord(2, 0, 3)))
self.assertEqual(self.ftsn.extent(TileCoord(2, 1, 1)), self.ftsf.extent(TileCoord(2, 1, 2)))
self.assertEqual(self.ftsn.extent(TileCoord(2, 2, 2)), self.ftsf.extent(TileCoord(2, 2, 1)))
self.assertEqual(self.ftsn.extent(TileCoord(2, 3, 3)), self.ftsf.extent(TileCoord(2, 3, 0)))
class TestFreeTileGridWithScale(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(resolutions=(4000, 2000, 1000, 500),
max_extent=(420000, 30000, 900000, 350000),
tile_size=100,
scale=100)
def test_extent(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6)),
(428000, 336000, 430000, 338000))
self.assertEqual(self.ftg.extent(TileCoord(1, 5, 7)),
(430000, 334000, 432000, 336000))
def test_extent_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6), 5),
(427900, 335900, 430100, 338100))
def test_extent_metatile(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2)),
(428000, 334000, 432000, 338000))
def test_extent_metatile_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2), 5),
(427900, 333900, 432100, 338100))
def test_tilecoord(self):
self.assertEqual(self.ftg.tilecoord(1, 428000, 336000),
TileCoord(1, 4, 7))
self.assertEqual(self.ftg.tilecoord(1, 430000, 334000),
TileCoord(1, 5, 8))
self.assertEqual(self.ftg.tilecoord(1, 432000, 332000),
TileCoord(1, 6, 9))
def setUp(self):
self.tilegrid = FreeTileGrid(
resolutions=(1000000, 500000, 1),
max_extent=(420000, 30000, 900000, 350000),
tile_size=100,
scale=10000,
)
class TestFreeTileGrid(unittest.TestCase):
def setUp(self) -> None:
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25,
10)
self.ftg = FreeTileGrid(self.resolutions)
def test_factors(self) -> None:
for i in range(len(self.resolutions)):
for child_z in self.ftg.child_zs[i]:
assert self.resolutions[i] % self.resolutions[child_z] == 0
def test_root_parents(self) -> None:
for root_z in {root.z for root in self.ftg.roots()}:
assert self.ftg.parent(TileCoord(root_z, 0, 0)) is None
def test_root_zero(self) -> None:
assert self.ftg.parent(TileCoord(0, 0, 0)) is None
def test_zs(self) -> None:
assert list(self.ftg.zs()) == [e for e in range(len(self.resolutions))]
class TestFreeTileGrid(unittest.TestCase):
def setUp(self):
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
self.ftg = FreeTileGrid(self.resolutions)
def test_factors(self):
for i in range(len(self.resolutions)):
for child_z in self.ftg.child_zs[i]:
assert self.resolutions[i] % self.resolutions[child_z] == 0
def test_root_parents(self):
for root_z in set(root.z for root in self.ftg.roots()):
assert self.ftg.parent(TileCoord(root_z, 0, 0)) is None
def test_root_zero(self):
assert self.ftg.parent(TileCoord(0, 0, 0)) is None
def test_zs(self):
assert list(self.ftg.zs()) == [e for e in range(len(self.resolutions))]
class TestFreeTileGrid(unittest.TestCase):
def setUp(self):
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
self.ftg = FreeTileGrid(self.resolutions)
def test_factors(self):
for i, resolution in enumerate(self.resolutions):
for child_z in self.ftg.child_zs[i]:
self.assertEquals(self.resolutions[i] % self.resolutions[child_z], 0)
def test_root_parents(self):
for root_z in set(root.z for root in self.ftg.roots()):
self.assertEquals(self.ftg.parent(TileCoord(root_z, 0, 0)), None)
def test_root_zero(self):
self.assertEquals(self.ftg.parent(TileCoord(0, 0, 0)), None)
def test_zs(self):
self.assertEquals(list(self.ftg.zs()), range(len(self.resolutions)))
class TestFreeTileGrid(unittest.TestCase):
def setUp(self):
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
self.ftg = FreeTileGrid(self.resolutions)
def test_factors(self):
for i in range(len(self.resolutions)):
for child_z in self.ftg.child_zs[i]:
self.assertEquals(self.resolutions[i] % self.resolutions[child_z], 0)
def test_root_parents(self):
for root_z in set(root.z for root in self.ftg.roots()):
self.assertEquals(self.ftg.parent(TileCoord(root_z, 0, 0)), None)
def test_root_zero(self):
self.assertEquals(self.ftg.parent(TileCoord(0, 0, 0)), None)
def test_zs(self):
self.assertEquals(list(self.ftg.zs()), [e for e in range(len(self.resolutions))])
class TestFreeQuadTileGridEquivalence(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
self.qtg = QuadTileGrid(max_zoom=3)
def test_children(self):
tc = TileCoord(2, 2, 3)
self.assertEqual(sorted(self.ftg.children(tc)), sorted(self.qtg.children(tc)))
def test_children_root(self):
tc = TileCoord(0, 0, 0)
self.assertEqual(sorted(self.ftg.children(tc)), sorted(self.qtg.children(tc)))
def test_extent(self):
for z in xrange(0, 4):
for x in xrange(0, 1 << z):
for y in xrange(0, 1 << z):
tilecoord = TileCoord(z, x, y)
self.assertEqual(self.ftg.extent(tilecoord), self.qtg.extent(tilecoord))
def test_parent(self):
tc = TileCoord(3, 3, 5)
self.assertEqual(self.ftg.parent(tc), self.qtg.parent(tc))
def test_roots(self):
self.assertEqual(list(self.ftg.roots()), list(self.qtg.roots()))
def test_zs(self):
self.assertEqual(list(self.ftg.zs()), list(self.qtg.zs()))
class TestFreeQuadTileGridEquivalence(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
self.qtg = QuadTileGrid(max_zoom=3)
def test_children(self):
tc = TileCoord(2, 2, 3)
assert sorted(self.ftg.children(tc)) == sorted(self.qtg.children(tc))
def test_children_root(self):
tc = TileCoord(0, 0, 0)
assert sorted(self.ftg.children(tc)) == sorted(self.qtg.children(tc))
def test_extent(self):
for z in xrange(0, 4):
for x in xrange(0, 1 << z):
for y in xrange(0, 1 << z):
tilecoord = TileCoord(z, x, y)
assert self.ftg.extent(tilecoord) == self.qtg.extent(tilecoord)
def test_parent(self):
tc = TileCoord(3, 3, 5)
assert self.ftg.parent(tc) == self.qtg.parent(tc)
def test_roots(self):
assert list(self.ftg.roots()) == list(self.qtg.roots())
def test_zs(self):
assert list(self.ftg.zs()) == list(self.qtg.zs())
class TestFreeTileGridWithScale(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(resolutions=(4000, 2000, 1000, 500), max_extent=(420000, 30000, 900000, 350000), tile_size=100, scale=100)
def test_extent(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6)), (428000, 336000, 430000, 338000))
self.assertEqual(self.ftg.extent(TileCoord(1, 5, 7)), (430000, 334000, 432000, 336000))
def test_extent_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6), 5), (427900, 335900, 430100, 338100))
def test_extent_metatile(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2)), (428000, 334000, 432000, 338000))
def test_extent_metatile_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2), 5), (427900, 333900, 432100, 338100))
def test_tilecoord(self):
self.assertEqual(self.ftg.tilecoord(1, 428000, 336000), TileCoord(1, 4, 7))
self.assertEqual(self.ftg.tilecoord(1, 430000, 334000), TileCoord(1, 5, 8))
self.assertEqual(self.ftg.tilecoord(1, 432000, 332000), TileCoord(1, 6, 9))
def setUp(self):
self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
self.qtg = QuadTileGrid(max_zoom=3)
def setUp(self):
self.ftsn = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125)
self.ftsf = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125, flip_y=True)
class TestFreeTileGridWithSubMetrics(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=100, scale=200)
self.ftg2 = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=256, scale=10)
def test_extent(self):
self.assertEqual(self.ftg.extent(TileCoord(0, 0, 0)), (420000, 349999, 420001, 350000))
self.assertEqual(self.ftg.extent(TileCoord(1, 0, 0)), (420000, 349999.5, 420000.5, 350000))
self.assertEqual(self.ftg2.extent(TileCoord(0, 0, 0)), (420000, 349948.8, 420051.2, 350000))
self.assertEqual(self.ftg2.extent(TileCoord(1, 0, 0)), (420000, 349974.4, 420025.6, 350000))
def test_extent_border(self):
self.assertEqual(self.ftg.extent(TileCoord(0, 0, 0), 50), (419999.5, 349998.5, 420001.5, 350000.5))
self.assertEqual(self.ftg.extent(TileCoord(1, 0, 0), 100), (419999.5, 349999, 420001, 350000.5))
self.assertEqual(self.ftg2.extent(TileCoord(0, 0, 0), 50), (419990.0, 349938.8, 420061.2, 350010))
self.assertEqual(self.ftg2.extent(TileCoord(1, 0, 0), 50), (419995, 349969.4, 420030.6, 350005))
def test_extent_metatile(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 0, 0, 3)), (420000, 349998.5, 420001.5, 350000))
self.assertEqual(self.ftg2.extent(TileCoord(1, 0, 0, 3)), (420000, 349923.2, 420076.8, 350000))
def test_extent_metatile_border(self):
self.assertEqual(
self.ftg.extent(TileCoord(1, 0, 0, 3), 50), (419999.75, 349998.25, 420001.75, 350000.25))
self.assertEqual(self.ftg2.extent(TileCoord(1, 0, 0, 3), 50), (419995, 349918.2, 420081.8, 350005))
def test_tilecoord(self):
self.assertEqual(self.ftg.tilecoord(0, 420000.75, 349999.25), TileCoord(0, 0, 0))
self.assertEqual(self.ftg.tilecoord(1, 420000.25, 349999.75), TileCoord(1, 0, 0))
self.assertEqual(self.ftg2.tilecoord(0, 420000.01, 349999.99), TileCoord(0, 0, 0))
self.assertEqual(self.ftg2.tilecoord(0, 420010, 349990), TileCoord(0, 0, 0))
self.assertEqual(self.ftg2.tilecoord(0, 420051.19, 349948.81), TileCoord(0, 0, 0))
self.assertEqual(self.ftg2.tilecoord(0, 420051.21, 349948.79), TileCoord(0, 1, 1))
class TestFreeTileGridWithSubMetrics(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=100, scale=200)
self.ftg2 = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=256, scale=10)
def test_extent(self):
assert self.ftg.extent(TileCoord(0, 0, 0)) == (420000, 349999, 420001, 350000)
assert self.ftg.extent(TileCoord(1, 0, 0)) == (420000, 349999.5, 420000.5, 350000)
assert self.ftg2.extent(TileCoord(0, 0, 0)) == (420000, 349948.8, 420051.2, 350000)
assert self.ftg2.extent(TileCoord(1, 0, 0)) == (420000, 349974.4, 420025.6, 350000)
def test_extent_border(self):
assert self.ftg.extent(TileCoord(0, 0, 0), 50) == (419999.5, 349998.5, 420001.5, 350000.5)
assert self.ftg.extent(TileCoord(1, 0, 0), 100) == (419999.5, 349999, 420001, 350000.5)
assert self.ftg2.extent(TileCoord(0, 0, 0), 50) == (419990.0, 349938.8, 420061.2, 350010)
assert self.ftg2.extent(TileCoord(1, 0, 0), 50) == (419995, 349969.4, 420030.6, 350005)
def test_extent_metatile(self):
assert self.ftg.extent(TileCoord(1, 0, 0, 3)) == (420000, 349998.5, 420001.5, 350000)
assert self.ftg2.extent(TileCoord(1, 0, 0, 3)) == (420000, 349923.2, 420076.8, 350000)
def test_extent_metatile_border(self):
assert self.ftg.extent(TileCoord(1, 0, 0, 3), 50) == (419999.75, 349998.25, 420001.75, 350000.25)
assert self.ftg2.extent(TileCoord(1, 0, 0, 3), 50) == (419995, 349918.2, 420081.8, 350005)
def test_tilecoord(self):
assert self.ftg.tilecoord(0, 420000.75, 349999.25) == TileCoord(0, 0, 0)
assert self.ftg.tilecoord(1, 420000.25, 349999.75) == TileCoord(1, 0, 0)
assert self.ftg2.tilecoord(0, 420000.01, 349999.99) == TileCoord(0, 0, 0)
assert self.ftg2.tilecoord(0, 420010, 349990) == TileCoord(0, 0, 0)
assert self.ftg2.tilecoord(0, 420051.19, 349948.81) == TileCoord(0, 0, 0)
assert self.ftg2.tilecoord(0, 420051.21, 349948.79) == TileCoord(0, 1, 1)
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=100, scale=200)
self.ftg2 = FreeTileGrid(
resolutions=(2, 1), max_extent=(420000, 30000, 900000, 350000), tile_size=256, scale=10)
def setUp(self):
self.ftsn = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125)
self.ftsf = FreeTileGrid(resolutions=(8, 4, 2, 1), tile_size=0.125, flip_y=True)
def __init__(self,
config_file,
options=None,
layer_name=None,
base_config=None):
self._close_actions = []
self._layers_geoms = {}
self.error_files_ = {}
if options is not None:
if not hasattr(options, 'bbox'):
options.bbox = None
if not hasattr(options, 'zoom'):
options.zoom = None
if not hasattr(options, 'test'):
options.test = None
if not hasattr(options, 'near'):
options.near = None
if not hasattr(options, 'time'):
options.time = None
if not hasattr(options, 'geom'):
options.geom = True
self._configure_logging(
options, '%(levelname)s:%(name)s:%(funcName)s:%(message)s')
with open(config_file) as f:
self.config = {}
self.config.update({} if base_config is None else base_config)
self.config.update(yaml.safe_load(f))
self.options = options
if 'defaults' in self.config:
del self.config['defaults']
# generate base structure
if 'cost' in self.config:
if 's3' not in self.config['cost']:
self.config['cost']['s3'] = {}
if 'cloudfront' not in self.config['cost']:
self.config['cost']['cloudfront'] = {}
if 'sqs' not in self.config['cost']:
self.config['cost']['sqs'] = {}
if 'generation' not in self.config:
self.config['generation'] = {}
for gname, grid in sorted(self.config.get('grids', {}).items()):
if grid is not None:
grid["name"] = gname
for cname, cache in sorted(self.config.get('caches', {}).items()):
if cache is not None:
cache["name"] = cname
for lname, layer in sorted(self.config.get('layers', {}).items()):
if layer is not None:
layer["name"] = lname
c = Core(
source_data=self.config,
schema_data=yaml.safe_load(
pkgutil.get_data("tilecloud_chain", "schema.yaml")),
)
path_ = ''
try:
self.config = c.validate()
for name, cache in self.config['caches'].items():
if cache['type'] == 's3':
c = Core(
source_data=cache,
schema_data=yaml.safe_load(
pkgutil.get_data("tilecloud_chain",
"schema-cache-s3.yaml")),
)
path_ = 'caches/{}'.format(name)
self.config['caches'][name] = c.validate()
for name, layer in self.config['layers'].items():
c = Core(
source_data=layer,
schema_data=yaml.safe_load(
pkgutil.get_data(
"tilecloud_chain",
"schema-layer-{}.yaml".format(layer['type']))),
)
path_ = 'layers/{}'.format(name)
self.config['layers'][name] = c.validate()
except SchemaError:
logger.error("The config file '{}' is invalid.\n{}".format(
config_file, "\n".join(
sorted([
" - {}: {}".format(
os.path.join('/', path_,
re.sub('^/', '', error.path)),
re.sub(" Path: '{path}'", '',
error.msg).format(**error.__dict__))
for error in c.errors
]))))
exit(1)
except NotSequenceError as e: # pragma: no cover
logger.error("The config file '{}' is invalid.\n - {}".format(
config_file, e.msg))
exit(1)
except NotMappingError as e: # pragma: no cover
logger.error("The config file '{}' is invalid.\n - {}".format(
config_file, e.msg))
exit(1)
error = False
self.grids = self.config['grids']
for gname, grid in sorted(self.grids.items()):
if 'resolution_scale' in grid:
scale = grid['resolution_scale']
for r in grid['resolutions']:
if r * scale % 1 != 0.0:
logger.error(
"The resolution {} * resolution_scale {} is not an integer."
.format(r, scale))
error = True
else:
grid['resolution_scale'] = self._resolution_scale(
grid['resolutions'])
srs = int(grid["srs"].split(":")[1])
if 'proj4_literal' not in grid:
if srs == 3857: # pragma: no cover
grid['proj4_literal'] = '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 ' \
'+x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over'
elif srs == 21781:
grid['proj4_literal'] = \
'+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 ' \
'+x_0=600000 +y_0=200000 +ellps=bessel +towgs84=674.374,15.056,405.346,0,0,0,0 ' \
'+units=m +no_defs'
elif srs == 2056: # pragma: no cover
grid['proj4_literal'] = \
'+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 ' \
'+x_0=2600000 +y_0=1200000 +ellps=bessel +towgs84=674.374,15.056,405.346,0,0,0,0 ' \
'+units=m +no_defs'
else: # pragma: no cover
grid['proj4_literal'] = '+init={}'.format(grid['srs'])
scale = grid['resolution_scale']
grid['obj'] = FreeTileGrid(
resolutions=[int(r * scale) for r in grid['resolutions']],
scale=scale,
max_extent=grid['bbox'],
tile_size=grid['tile_size']) if not error else None
self.layers = self.config['layers']
for lname, layer in sorted(self.layers.items()):
layer['grid_ref'] = self.grids[
layer['grid']] if not error else None
self.layers[lname] = layer
if 'geoms' not in layer:
layer['geoms'] = []
if 'params' not in layer and layer['type'] == 'wms':
layer['params'] = {}
if 'headers' not in layer and layer['type'] == 'wms':
layer['headers'] = {
'Cache-Control': 'no-cache, no-store',
'Pragma': 'no-cache',
}
if 'dimensions' not in layer:
layer['dimensions'] = []
if layer['type'] == 'mapnik' and \
layer['output_format'] == 'grid' and \
layer.get('meta', False): # pragma: no cover
logger.error(
"The layer '{}' is of type Mapnik/Grid, that can't support matatiles."
.format(lname))
error = True
self.caches = self.config['caches']
self.metadata = self.config.get('metadata')
self.provider = self.config.get('provider')
if error:
exit(1)
if 'log_format' in self.config.get('generation', {}):
self._configure_logging(options,
self.config['generation']['log_format'])
if options is not None and options.zoom is not None:
error_message = (
"The zoom argument '%s' has incorrect format, "
"it can be a single value, a range (3-9), a list of values (2,5,7)."
) % options.zoom
if options.zoom.find('-') >= 0:
r = options.zoom.split('-')
if len(r) != 2: # pragma: no cover
logger.error(error_message)
error = True
try:
options.zoom = range(int(r[0]), int(r[1]) + 1)
except ValueError: # pragma: no cover
logger.error(error_message, exc_info=True)
error = True
elif options.zoom.find(',') >= 0:
try:
options.zoom = [int(z) for z in options.zoom.split(',')]
except ValueError: # pragma: no cover
logger.error(error_message, exc_info=True)
error = True
else:
try:
options.zoom = [int(options.zoom)]
except ValueError: # pragma: no cover
logger.error(error_message, exc_info=True)
error = True
if error: # pragma: no cover
exit(1)
if layer_name and not error:
self.init_layer(self.layers[layer_name], options)
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(4000, 2000, 1000, 500), max_extent=(420000, 30000, 900000, 350000),
tile_size=100, scale=100)
class TestFreeTileGrid2(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(750, 20, 10, 5), max_extent=(420000, 30000, 900000, 350000), tile_size=100)
def test_extent(self):
self.assertEqual(self.ftg.extent(TileCoord(0, 0, 0)), (420000, 275000, 495000, 350000))
self.assertEqual(self.ftg.extent(TileCoord(1, 0, 0)), (420000, 348000, 422000, 350000))
self.assertEqual(self.ftg.extent(TileCoord(2, 0, 0)), (420000, 349000, 421000, 350000))
self.assertEqual(self.ftg.extent(TileCoord(3, 0, 0)), (420000, 349500, 420500, 350000))
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6)), (428000, 336000, 430000, 338000))
self.assertEqual(self.ftg.extent(TileCoord(1, 5, 7)), (430000, 334000, 432000, 336000))
def test_extent_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6), 5), (427900, 335900, 430100, 338100))
def test_extent_metatile(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2)), (428000, 334000, 432000, 338000))
def test_extent_metatile_border(self):
self.assertEqual(self.ftg.extent(TileCoord(1, 4, 6, 2), 5), (427900, 333900, 432100, 338100))
def test_tilecoord(self):
self.assertEqual(self.ftg.tilecoord(1, 428000, 336000), TileCoord(1, 4, 7))
self.assertEqual(self.ftg.tilecoord(1, 428000.1, 336000.1), TileCoord(1, 4, 6))
self.assertEqual(self.ftg.tilecoord(1, 429999.9, 337999.9), TileCoord(1, 4, 6))
self.assertEqual(self.ftg.tilecoord(1, 430000, 338000), TileCoord(1, 5, 6))
self.assertEqual(self.ftg.tilecoord(1, 430000, 334000), TileCoord(1, 5, 8))
self.assertEqual(self.ftg.tilecoord(1, 431000, 335000), TileCoord(1, 5, 7))
self.assertEqual(self.ftg.tilecoord(1, 432000, 336000), TileCoord(1, 6, 7))
self.assertEqual(self.ftg.tilecoord(1, 432000, 333000), TileCoord(1, 6, 8))
def test_zs(self):
self.assertEqual(list(self.ftg.zs()), [0, 1, 2, 3])
def setUp(self):
self.ftg = FreeTileGrid([8, 4, 2, 1], tile_size=0.125)
self.qtg = QuadTileGrid(max_zoom=3)
def setUp(self):
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
self.ftg = FreeTileGrid(self.resolutions)
def setUp(self):
self.resolutions = (1000, 999, 500, 250, 125, 123, 111, 100, 50, 25, 10)
self.ftg = FreeTileGrid(self.resolutions)
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(750, 20, 10, 5), max_extent=(420000, 30000, 900000, 350000), tile_size=100)
class TestFreeTileGrid2(unittest.TestCase):
def setUp(self):
self.ftg = FreeTileGrid(
resolutions=(750, 20, 10, 5), max_extent=(420000, 30000, 900000, 350000), tile_size=100)
def test_extent(self):
assert self.ftg.extent(TileCoord(0, 0, 0)) == (420000, 275000, 495000, 350000)
assert self.ftg.extent(TileCoord(1, 0, 0)) == (420000, 348000, 422000, 350000)
assert self.ftg.extent(TileCoord(2, 0, 0)) == (420000, 349000, 421000, 350000)
assert self.ftg.extent(TileCoord(3, 0, 0)) == (420000, 349500, 420500, 350000)
assert self.ftg.extent(TileCoord(1, 4, 6)) == (428000, 336000, 430000, 338000)
assert self.ftg.extent(TileCoord(1, 5, 7)) == (430000, 334000, 432000, 336000)
def test_extent_border(self):
assert self.ftg.extent(TileCoord(1, 4, 6), 5) == (427900, 335900, 430100, 338100)
def test_extent_metatile(self):
assert self.ftg.extent(TileCoord(1, 4, 6, 2)) == (428000, 334000, 432000, 338000)
def test_extent_metatile_border(self):
assert self.ftg.extent(TileCoord(1, 4, 6, 2), 5) == (427900, 333900, 432100, 338100)
def test_tilecoord(self):
assert self.ftg.tilecoord(1, 428000, 336000) == TileCoord(1, 4, 7)
assert self.ftg.tilecoord(1, 428000.1, 336000.1) == TileCoord(1, 4, 6)
assert self.ftg.tilecoord(1, 429999.9, 337999.9) == TileCoord(1, 4, 6)
assert self.ftg.tilecoord(1, 430000, 338000) == TileCoord(1, 5, 6)
assert self.ftg.tilecoord(1, 430000, 334000) == TileCoord(1, 5, 8)
assert self.ftg.tilecoord(1, 431000, 335000) == TileCoord(1, 5, 7)
assert self.ftg.tilecoord(1, 432000, 336000) == TileCoord(1, 6, 7)
assert self.ftg.tilecoord(1, 432000, 333000) == TileCoord(1, 6, 8)
def test_zs(self):
assert list(self.ftg.zs()) == [0, 1, 2, 3]
