def test_limited_unsupported(self):
assert limit_srs_extents(
{
"EPSG:9999": DefaultMapExtent(),
"EPSG:4326": MapExtent([0, 0, 10, 10], SRS(4326)),
},
["EPSG:4326", "EPSG:3857"],
) == {"EPSG:4326": MapExtent([0, 0, 10, 10], SRS(4326))}
def test_limited_unsupported(self):
eq_(
limit_srs_extents(
{
'EPSG:9999': DefaultMapExtent(),
'EPSG:4326': MapExtent([0, 0, 10, 10], SRS(4326))
}, ['EPSG:4326', 'EPSG:3857']), {
'EPSG:4326': MapExtent([0, 0, 10, 10], SRS(4326)),
})
class TestMapExtent(object):
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def test_bbox(self):
assert bbox_equals(self.extent.bbox, [-10, 10, 80, 80], 0.0001)
def test_contains(self):
assert self.extent.contains(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.contains(MapExtent((15, 15, 79, 20), SRS(4326)))
assert self.extent.contains(MapExtent((9, 10, 20, 20), SRS(4326)))
assert not self.extent.contains(MapExtent((9, 9.99999999, 20, 20), SRS(4326)))
def test_intersects(self):
assert self.extent.intersects(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((15, 15, 80, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((9, 10, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((-30, 10, -8, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((-30, 10, -11, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((0, 0, 1000, 1000), SRS(900913)))
assert self.extent.intersects(MapExtent((0, 0, 1500000, 1500000), SRS(900913)))
def test_eq(self):
assert MapExtent([-10, 10, 80, 80], SRS(4326)) == MapExtent([-10, 10, 80, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) == MapExtent([-10, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent([-10.1, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent([-10, 10.0, 80.0, 80], SRS(31467))
class TestMapExtent(object):
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def test_bbox(self):
assert bbox_equals(self.extent.bbox, [-10, 10, 80, 80], 0.0001)
def test_contains(self):
assert self.extent.contains(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.contains(MapExtent((15, 15, 79, 20), SRS(4326)))
assert self.extent.contains(MapExtent((9, 10, 20, 20), SRS(4326)))
assert not self.extent.contains(
MapExtent((9, 9.99999999, 20, 20), SRS(4326)))
def test_intersects(self):
assert self.extent.intersects(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((15, 15, 80, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((9, 10, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((-30, 10, -8, 70), SRS(4326)))
assert not self.extent.intersects(
MapExtent((-30, 10, -11, 70), SRS(4326)))
assert not self.extent.intersects(
MapExtent((0, 0, 1000, 1000), SRS(900913)))
assert self.extent.intersects(
MapExtent((0, 0, 1500000, 1500000), SRS(900913)))
def test_eq(self):
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10, 80, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10.0, 80.0, 80],
SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10.1, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10, 10.0, 80.0, 80], SRS(31467))
def test_intersection(self):
assert (DefaultMapExtent().intersection(
MapExtent((0, 0, 10, 10), SRS(4326))) == MapExtent((0, 0, 10, 10),
SRS(4326)))
assert (MapExtent(
(0, 0, 10, 10),
SRS(4326)).intersection(MapExtent((20, 20, 30, 30),
SRS(4326))) == None)
sub = MapExtent((0, 0, 10, 10), SRS(4326)).intersection(
MapExtent((-1000, -1000, 100000, 100000), SRS(3857)))
bbox = SRS(3857).transform_bbox_to(SRS(4326), (0, 0, 100000, 100000),
0)
assert bbox_equals(bbox, sub.bbox)
def __init__(self,
client,
image_opts=None,
coverage=None,
res_range=None,
transparent_color=None,
transparent_color_tolerance=None,
supported_srs=None,
supported_formats=None,
fwd_req_params=None):
MapLayer.__init__(self, image_opts=image_opts)
self.client = client
self.supported_srs = supported_srs or []
self.supported_formats = supported_formats or []
self.fwd_req_params = fwd_req_params or set()
self.transparent_color = transparent_color
self.transparent_color_tolerance = transparent_color_tolerance
if self.transparent_color:
self.image_opts.transparent = True
self.coverage = coverage
self.res_range = res_range
if self.coverage:
self.extent = MapExtent(self.coverage.bbox, self.coverage.srs)
else:
self.extent = DefaultMapExtent()
def display_grid(grid_conf, coverage=None):
print '%s:' % (grid_conf.conf['name'], )
print ' Configuration:'
conf_dict = grid_conf.conf.copy()
tile_grid = grid_conf.tile_grid()
if 'tile_size' not in conf_dict:
conf_dict['tile_size*'] = tile_grid.tile_size
if 'bbox' not in conf_dict:
conf_dict['bbox*'] = tile_grid.bbox
if 'origin' not in conf_dict:
conf_dict['origin*'] = tile_grid.origin or 'sw'
area_ratio = None
if coverage:
bbox = conf_dict.get('bbox', tile_grid.bbox)
area_ratio = grid_coverage_ratio(
MapExtent(bbox, tile_grid.srs),
MapExtent(coverage.bbox, coverage.srs))
for key in sorted(conf_dict):
if key == 'name':
continue
print ' %s: %s' % (key, format_conf_value(conf_dict[key]))
if coverage:
print ' Coverage: %s covers approx. %.4f%% of the grid BBOX' % (
coverage.name, area_ratio * 100)
print ' Levels: Resolutions, # x * y = total tiles (approx. tiles within coverage)'
else:
print ' Levels: Resolutions, # x * y = total tiles'
max_digits = max([
len("%r" % (res, )) for level, res in enumerate(tile_grid.resolutions)
])
for level, res in enumerate(tile_grid.resolutions):
tiles_in_x, tiles_in_y = tile_grid.grid_sizes[level]
total_tiles = tiles_in_x * tiles_in_y
spaces = max_digits - len("%r" % (res, )) + 1
if coverage:
coverage_tiles = total_tiles * area_ratio
print " %.2d: %r,%s# %6d * %-6d = %8s (%s)" % (
level, res, ' ' * spaces, tiles_in_x, tiles_in_y,
human_readable_number(total_tiles),
human_readable_number(coverage_tiles))
else:
print " %.2d: %r,%s# %6d * %-6d = %8s" % (
level, res, ' ' * spaces, tiles_in_x, tiles_in_y,
human_readable_number(total_tiles))
def test_eq(self):
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10, 80, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10.0, 80.0, 80],
SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10.1, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10, 10.0, 80.0, 80], SRS(31467))
def test_intersects(self):
assert self.extent.intersects(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((15, 15, 80, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((9, 10, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((-30, 10, -8, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((-30, 10, -11, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((0, 0, 1000, 1000), SRS(900913)))
assert self.extent.intersects(MapExtent((0, 0, 1500000, 1500000), SRS(900913)))
def __init__(self, mapfile, layers=None, image_opts=None, coverage=None, res_range=None, lock=None):
Source.__init__(self, image_opts=image_opts)
self.mapfile = mapfile
self.coverage = coverage
self.res_range = res_range
self.layers = set(layers) if layers else None
self.lock = lock
if self.coverage:
self.extent = MapExtent(self.coverage.bbox, self.coverage.srs)
else:
self.extent = DefaultMapExtent()
def _get_map(self, query):
format = self.image_opts.format
if not format:
format = query.format
if self.supported_formats and format not in self.supported_formats:
format = self.supported_formats[0]
if self.supported_srs:
if query.srs not in self.supported_srs:
return self._get_transformed(query, format)
if self.extent and not self.extent.contains(MapExtent(query.bbox, query.srs)):
return self._get_sub_query(query, format)
resp = self.client.retrieve(query, format)
return ImageSource(resp, size=query.size, image_opts=self.image_opts)
def __init__(self, mapfile, layers=None, image_opts=None, coverage=None,
res_range=None, lock=None, reuse_map_objects=False):
MapLayer.__init__(self, image_opts=image_opts)
self.mapfile = mapfile
self.coverage = coverage
self.res_range = res_range
self.layers = set(layers) if layers else None
self.lock = lock
self._map_objs = {}
self._map_objs_lock = threading.Lock()
self._cache_map_obj = reuse_map_objects
if self.coverage:
self.extent = MapExtent(self.coverage.bbox, self.coverage.srs)
else:
self.extent = DefaultMapExtent()
def test_intersection(self):
assert (DefaultMapExtent().intersection(MapExtent((0, 0, 10, 10), SRS(4326)))
== MapExtent((0, 0, 10, 10), SRS(4326)))
assert (MapExtent((0, 0, 10, 10), SRS(4326)).intersection(MapExtent((20, 20, 30, 30), SRS(4326)))
== None)
sub = MapExtent((0, 0, 10, 10), SRS(4326)).intersection(MapExtent((-1000, -1000, 100000, 100000), SRS(3857)))
bbox = SRS(3857).transform_bbox_to(SRS(4326), (0, 0, 100000, 100000), 0)
assert bbox_equals(bbox, sub.bbox)
class TestMapExtent(object):
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def test_bbox(self):
assert bbox_equals(self.extent.bbox, [-10, 10, 80, 80], 0.0001)
def test_contains(self):
assert self.extent.contains(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.contains(MapExtent((15, 15, 79, 20), SRS(4326)))
assert self.extent.contains(MapExtent((9, 10, 20, 20), SRS(4326)))
assert not self.extent.contains(MapExtent((9, 9.99999999, 20, 20), SRS(4326)))
def test_intersects(self):
assert self.extent.intersects(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((15, 15, 80, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((9, 10, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((-30, 10, -8, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((-30, 10, -11, 70), SRS(4326)))
assert not self.extent.intersects(MapExtent((0, 0, 1000, 1000), SRS(900913)))
assert self.extent.intersects(MapExtent((0, 0, 1500000, 1500000), SRS(900913)))
def test_eq(self):
assert MapExtent([-10, 10, 80, 80], SRS(4326)) == MapExtent([-10, 10, 80, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) == MapExtent([-10, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent([-10.1, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent([-10, 10.0, 80.0, 80], SRS(31467))
def test_intersection(self):
assert (DefaultMapExtent().intersection(MapExtent((0, 0, 10, 10), SRS(4326)))
== MapExtent((0, 0, 10, 10), SRS(4326)))
assert (MapExtent((0, 0, 10, 10), SRS(4326)).intersection(MapExtent((20, 20, 30, 30), SRS(4326)))
== None)
sub = MapExtent((0, 0, 10, 10), SRS(4326)).intersection(MapExtent((-1000, -1000, 100000, 100000), SRS(3857)))
bbox = SRS(3857).transform_bbox_to(SRS(4326), (0, 0, 100000, 100000), 0)
assert bbox_equals(bbox, sub.bbox)
def _get_map(self, query):
format = self.image_opts.format
if not format:
format = query.format
if self.supported_formats and format not in self.supported_formats:
format = self.supported_formats[0]
if self.supported_srs:
if query.srs not in self.supported_srs:
return self._get_transformed(query, format)
# some srs are equal but not the same (e.g. 900913/3857)
# use only supported srs so we use the right srs code.
idx = self.supported_srs.index(query.srs)
if self.supported_srs[idx] is not query.srs:
query.srs = self.supported_srs[idx]
if self.extent and not self.extent.contains(MapExtent(query.bbox, query.srs)):
return self._get_sub_query(query, format)
resp = self.client.retrieve(query, format)
return ImageSource(resp, size=query.size, image_opts=self.image_opts)
class TestMapExtent(object):
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def test_bbox(self):
assert bbox_equals(self.extent.bbox, [-10, 10, 80, 80], 0.0001)
def test_contains(self):
assert self.extent.contains(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.contains(MapExtent((15, 15, 79, 20), SRS(4326)))
assert self.extent.contains(MapExtent((9, 10, 20, 20), SRS(4326)))
assert not self.extent.contains(
MapExtent((9, 9.99999999, 20, 20), SRS(4326)))
def test_intersects(self):
assert self.extent.intersects(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((15, 15, 80, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((9, 10, 20, 20), SRS(4326)))
assert self.extent.intersects(MapExtent((-30, 10, -8, 70), SRS(4326)))
assert not self.extent.intersects(
MapExtent((-30, 10, -11, 70), SRS(4326)))
assert not self.extent.intersects(
MapExtent((0, 0, 1000, 1000), SRS(900913)))
assert self.extent.intersects(
MapExtent((0, 0, 1500000, 1500000), SRS(900913)))
def test_eq(self):
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10, 80, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80],
SRS(4326)) == MapExtent([-10, 10.0, 80.0, 80],
SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10.1, 10.0, 80.0, 80], SRS(4326))
assert MapExtent([-10, 10, 80, 80], SRS(4326)) != MapExtent(
[-10, 10.0, 80.0, 80], SRS(31467))
def __init__(self,
mapfile,
layers=None,
image_opts=None,
coverage=None,
res_range=None,
lock=None,
reuse_map_objects=None,
scale_factor=None):
MapLayer.__init__(self, image_opts=image_opts)
self.mapfile = mapfile
self.coverage = coverage
self.res_range = res_range
self.layers = set(layers) if layers else None
self.scale_factor = scale_factor
self.lock = lock
self._map_holder = threading.local()
self._map_holder.__dict__.setdefault('map', None)
if self.coverage:
self.extent = MapExtent(self.coverage.bbox, self.coverage.srs)
else:
self.extent = DefaultMapExtent()
# initialize map object
self.map_obj()
ResolutionConditional,
SRSConditional,
)
from mapproxy.request.wms import WMS111MapRequest
from mapproxy.source import InvalidSourceQuery, SourceError
from mapproxy.source.tile import TiledSource
from mapproxy.source.wms import WMSSource
from mapproxy.source.error import HTTPSourceErrorHandler
from mapproxy.srs import SRS, SupportedSRS, PreferredSrcSRS
from mapproxy.test.http import assert_query_eq, wms_query_eq, query_eq, mock_httpd
from mapproxy.test.image import create_debug_img, is_png, tmp_image, create_tmp_image_buf
from mapproxy.util.coverage import BBOXCoverage
TEST_SERVER_ADDRESS = ('127.0.0.1', 56413)
GLOBAL_GEOGRAPHIC_EXTENT = MapExtent((-180, -90, 180, 90), SRS(4326))
tmp_lock_dir = None
def setup():
global tmp_lock_dir
tmp_lock_dir = tempfile.mkdtemp()
def teardown():
shutil.rmtree(tmp_lock_dir)
class counting_set(object):
def __init__(self, items):
self.data = defaultdict(int)
for item in items:
self.data[item] += 1
def add(self, item):
def __init__(self, coverage=None):
MapLayer.__init__(self)
self.extent = MapExtent((-180, -90, 180, 90), SRS(4326))
self.extent = MapExtent(coverage.bbox, coverage.srs) if coverage else DefaultMapExtent()
def test_contains(self):
assert self.extent.contains(MapExtent((15, 15, 20, 20), SRS(4326)))
assert self.extent.contains(MapExtent((15, 15, 79, 20), SRS(4326)))
assert self.extent.contains(MapExtent((9, 10, 20, 20), SRS(4326)))
assert not self.extent.contains(
MapExtent((9, 9.99999999, 20, 20), SRS(4326)))
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def __init__(self, coverage=None):
Source.__init__(self)
self.extent = MapExtent((-180, -90, 180, 90), SRS(4326))
self.transparent = True
self.extent = MapExtent(
coverage.bbox, coverage.srs) if coverage else DefaultMapExtent()
def setup(self):
self.extent = MapExtent([-10, 10, 80, 80], SRS(4326))
def map(self, map_request):
self.check_map_request(map_request)
params = map_request.params
query = MapQuery(params.bbox, params.size, SRS(params.srs),
params.format)
if map_request.params.get('tiled', 'false').lower() == 'true':
query.tiled_only = True
orig_query = query
if self.srs_extents and params.srs in self.srs_extents:
# limit query to srs_extent if query is larger
query_extent = MapExtent(params.bbox, SRS(params.srs))
if not self.srs_extents[params.srs].contains(query_extent):
limited_extent = self.srs_extents[params.srs].intersection(
query_extent)
if not limited_extent:
img_opts = self.image_formats[
params.format_mime_type].copy()
img_opts.bgcolor = params.bgcolor
img_opts.transparent = params.transparent
img = BlankImageSource(size=params.size,
image_opts=img_opts,
cacheable=True)
return Response(img.as_buffer(),
content_type=img_opts.format.mime_type)
sub_size, offset, sub_bbox = bbox_position_in_image(
params.bbox, params.size, limited_extent.bbox)
query = MapQuery(sub_bbox, sub_size, SRS(params.srs),
params.format)
actual_layers = odict()
for layer_name in map_request.params.layers:
layer = self.layers[layer_name]
# only add if layer renders the query
if layer.renders_query(query):
# if layer is not transparent and will be rendered,
# remove already added (then hidden) layers
if not layer.transparent:
actual_layers = odict()
for layer_name, map_layers in layer.map_layers_for_query(
query):
actual_layers[layer_name] = map_layers
authorized_layers, coverage = self.authorized_layers(
'map',
actual_layers.keys(),
map_request.http.environ,
query_extent=(query.srs.srs_code, query.bbox))
self.filter_actual_layers(actual_layers, map_request.params.layers,
authorized_layers)
render_layers = []
for layers in actual_layers.values():
render_layers.extend(layers)
self.update_query_with_fwd_params(query,
params=params,
layers=render_layers)
raise_source_errors = True if self.on_error == 'raise' else False
renderer = LayerRenderer(
render_layers,
query,
map_request,
raise_source_errors=raise_source_errors,
concurrent_rendering=self.concurrent_layer_renderer)
merger = LayerMerger()
renderer.render(merger)
if self.attribution and self.attribution.get(
'text') and not query.tiled_only:
merger.add(attribution_image(self.attribution['text'], query.size))
img_opts = self.image_formats[params.format_mime_type].copy()
img_opts.bgcolor = params.bgcolor
img_opts.transparent = params.transparent
result = merger.merge(size=query.size,
image_opts=img_opts,
bbox=query.bbox,
bbox_srs=params.srs,
coverage=coverage)
if query != orig_query:
result = SubImageSource(result,
size=orig_query.size,
offset=offset,
image_opts=img_opts)
# Provide the wrapping WSGI app or filter the opportunity to process the
# image before it's wrapped up in a response
result = self.decorate_img(result, 'wms.map', actual_layers.keys(),
map_request.http.environ,
(query.srs.srs_code, query.bbox))
try:
result_buf = result.as_buffer(img_opts)
except IOError as ex:
raise RequestError('error while processing image file: %s' % ex,
request=map_request)
resp = Response(result_buf, content_type=img_opts.format.mime_type)
if query.tiled_only and isinstance(result.cacheable, CacheInfo):
cache_info = result.cacheable
resp.cache_headers(cache_info.timestamp,
etag_data=(cache_info.timestamp,
cache_info.size),
max_age=self.max_tile_age)
resp.make_conditional(map_request.http)
if not result.cacheable:
resp.cache_headers(no_cache=True)
return resp
def extent(self):
from mapproxy.layer import MapExtent
return MapExtent(self.bbox, self.srs)
