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
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 not query.tiled_only:
merger.add(attribution_image(self.attribution['text'], params.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=params.size, image_opts=img_opts,
bbox=params.bbox, bbox_srs=params.srs, coverage=coverage)
# 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, ex:
raise RequestError('error while processing image file: %s' % ex,
request=map_request)
def child_layers(self):
layers = odict()
if self.name:
layers[self.name] = self
for lyr in self.layers:
if hasattr(lyr, 'child_layers'):
layers.update(lyr.child_layers())
elif lyr.name:
layers[lyr.name] = lyr
return layers
def child_layers(self):
layers = odict()
if self.name:
layers[self.name] = self
for lyr in self.layers:
if hasattr(lyr, "child_layers"):
layers.update(lyr.child_layers())
elif lyr.name:
layers[lyr.name] = lyr
return layers
def _matrix_sets(self, layers):
sets = {}
layers_grids = odict()
for layer in layers.values():
grid = layer.grid
if not grid.supports_access_with_origin('nw'):
log.warning("skipping layer '%s' for WMTS, grid '%s' of cache '%s' is not compatible with WMTS",
layer.name, grid.name, layer.md['cache_name'])
continue
if grid.name not in sets:
try:
sets[grid.name] = TileMatrixSet(grid)
except AssertionError:
continue # TODO
layers_grids.setdefault(layer.name, odict())[grid.name] = layer
wmts_layers = odict()
for layer_name, layers in layers_grids.items():
wmts_layers[layer_name] = WMTSTileLayer(layers)
return wmts_layers, sets.values()
def _matrix_sets(self, layers):
sets = {}
layers_grids = odict()
for layer in layers.values():
grid = layer.grid
if not grid.supports_access_with_origin('nw'):
log.warn("skipping layer '%s' for WMTS, grid '%s' of cache '%s' is not compatible with WMTS",
layer.name, grid.name, layer.md['cache_name'])
continue
if grid.name not in sets:
try:
sets[grid.name] = TileMatrixSet(grid)
except AssertionError:
continue # TODO
layers_grids.setdefault(layer.name, odict())[grid.name] = layer
wmts_layers = odict()
for layer_name, layers in layers_grids.items():
wmts_layers[layer_name] = WMTSTileLayer(layers)
return wmts_layers, sets.values()
def authorized_tile_layers(self, env):
if 'mapproxy.authorize' in env:
result = env['mapproxy.authorize']('tms', [l for l in self.layers], environ=env)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return self.layers
if result['authorized'] == 'none':
raise RequestError('forbidden', status=403)
allowed_layers = odict()
for layer in self.layers.itervalues():
if result['layers'].get(layer.name, {}).get('tile', False) == True:
allowed_layers[layer.name] = layer
return allowed_layers
else:
return self.layers
def setup(self):
# Base server
self.server = Server()
# WMS Server
root_layer = WMSGroupLayer(None, 'root layer', None, [DummyLayer('wms_cache')])
self.wms_server = WMSServer(
md={}, root_layer=root_layer, srs=['EPSG:4326'],
image_formats={'image/png': ImageOptions(format='image/png')}
)
# Tile Servers
layers = odict()
layers["wms_cache_EPSG900913"] = DummyTileLayer('wms_cache')
self.tile_server = TileServer(layers, {})
self.wmts_server = WMTSServer(layers, {})
# Common arguments
self.query_extent = ('EPSG:27700', (0, 0, 700000, 1300000))
def setup(self):
# Base server
self.server = Server()
# WMS Server
root_layer = WMSGroupLayer(None, 'root layer', None, [DummyLayer('wms_cache')])
self.wms_server = WMSServer(
md={}, root_layer=root_layer, srs=['EPSG:4326'],
image_formats={'image/png': ImageOptions(format='image/png')}
)
# Tile Servers
layers = odict()
layers["wms_cache_EPSG900913"] = DummyTileLayer('wms_cache')
self.tile_server = TileServer(layers, {})
self.wmts_server = WMTSServer(layers, {})
# Common arguments
self.query_extent = ('EPSG:27700', (0, 0, 700000, 1300000))
def authorized_tile_layers(self, env):
if 'mapproxy.authorize' in env:
result = env['mapproxy.authorize']('tms', [l for l in self.layers],
query_extent=None, environ=env)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return self.layers
if result['authorized'] == 'none':
raise RequestError('forbidden', status=403)
allowed_layers = odict()
for layer in self.layers.itervalues():
if result['layers'].get(layer.name, {}).get('tile', False) == True:
allowed_layers[layer.name] = layer
return allowed_layers
else:
return self.layers
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 featureinfo(self, request):
infos = []
self.check_featureinfo_request(request)
p = request.params
query = InfoQuery(p.bbox,
p.size,
SRS(p.srs),
p.pos,
p['info_format'],
format=request.params.format or None,
feature_count=p.get('feature_count'))
actual_layers = odict()
for layer_name in request.params.query_layers:
layer = self.layers[layer_name]
if not layer.queryable:
raise RequestError('layer %s is not queryable' % layer_name,
request=request)
for layer_name, info_layers in layer.info_layers_for_query(query):
actual_layers[layer_name] = info_layers
authorized_layers, coverage = self.authorized_layers(
'featureinfo',
actual_layers.keys(),
request.http.environ,
query_extent=(query.srs.srs_code, query.bbox))
self.filter_actual_layers(actual_layers, request.params.layers,
authorized_layers)
# outside of auth-coverage
if coverage and not coverage.contains(query.coord, query.srs):
infos = []
else:
info_layers = []
for layers in actual_layers.values():
info_layers.extend(layers)
for layer in info_layers:
info = layer.get_info(query)
if info is None:
continue
infos.append(info)
mimetype = None
if 'info_format' in request.params:
mimetype = request.params.info_format
if not infos:
return Response('', mimetype=mimetype)
if self.fi_transformers:
doc = infos[0].combine(infos)
if doc.info_type == 'text':
resp = doc.as_string()
mimetype = 'text/plain'
else:
if not mimetype:
if 'xml' in self.fi_transformers:
info_type = 'xml'
elif 'html' in self.fi_transformers:
info_type = 'html'
else:
info_type = 'text'
mimetype = mimetype_from_infotype(request.version,
info_type)
else:
info_type = infotype_from_mimetype(request.version,
mimetype)
resp = self.fi_transformers[info_type](doc).as_string()
else:
mimetype = mimetype_from_infotype(request.version,
infos[0].info_type)
if len(infos) > 1:
resp = infos[0].combine(infos).as_string()
else:
resp = infos[0].as_string()
return Response(resp, mimetype=mimetype)
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
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 not query.tiled_only:
merger.add(attribution_image(self.attribution["text"], params.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=params.size, image_opts=img_opts, bbox=params.bbox, bbox_srs=params.srs, coverage=coverage
)
resp = Response(result.as_buffer(img_opts), 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 featureinfo(self, request):
infos = []
self.check_featureinfo_request(request)
p = request.params
query = InfoQuery(
p.bbox,
p.size,
SRS(p.srs),
p.pos,
p["info_format"],
format=request.params.format or None,
feature_count=p.get("feature_count"),
)
actual_layers = odict()
for layer_name in request.params.query_layers:
layer = self.layers[layer_name]
if not layer.queryable:
raise RequestError("layer %s is not queryable" % layer_name, request=request)
for layer_name, info_layers in layer.info_layers_for_query(query):
actual_layers[layer_name] = info_layers
authorized_layers, coverage = self.authorized_layers(
"featureinfo", actual_layers.keys(), request.http.environ, query_extent=(query.srs.srs_code, query.bbox)
)
self.filter_actual_layers(actual_layers, request.params.layers, authorized_layers)
# outside of auth-coverage
if coverage and not coverage.contains(query.coord, query.srs):
infos = []
else:
info_layers = []
for layers in actual_layers.values():
info_layers.extend(layers)
for layer in info_layers:
info = layer.get_info(query)
if info is None:
continue
infos.append(info)
mimetype = None
if "info_format" in request.params:
mimetype = request.params.info_format
if not infos:
return Response("", mimetype=mimetype)
if self.fi_transformers:
doc = infos[0].combine(infos)
if doc.info_type == "text":
resp = doc.as_string()
mimetype = "text/plain"
else:
if not mimetype:
if "xml" in self.fi_transformers:
info_type = "xml"
elif "html" in self.fi_transformers:
info_type = "html"
else:
info_type = "text"
mimetype = mimetype_from_infotype(request.version, info_type)
else:
info_type = infotype_from_mimetype(request.version, mimetype)
resp = self.fi_transformers[info_type](doc).as_string()
else:
mimetype = mimetype_from_infotype(request.version, infos[0].info_type)
if len(infos) > 1:
resp = infos[0].combine(infos).as_string()
else:
resp = infos[0].as_string()
return Response(resp, mimetype=mimetype)
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
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 not query.tiled_only:
merger.add(attribution_image(self.attribution['text'],
params.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=params.size,
image_opts=img_opts,
bbox=params.bbox,
bbox_srs=params.srs,
coverage=coverage)
# 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, ex:
raise RequestError('error while processing image file: %s' % ex,
request=map_request)
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
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 not query.tiled_only:
merger.add(attribution_image(self.attribution['text'],
params.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=params.size,
image_opts=img_opts,
bbox=params.bbox,
bbox_srs=params.srs,
coverage=coverage)
resp = Response(result.as_buffer(img_opts),
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 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