def kml(self, map_request):
"""
:return: the rendered KML response
"""
layer = self.layer(map_request)
self.authorize_tile_layer(layer, map_request)
tile_coord = map_request.tile
initial_level = False
if tile_coord[2] == 0:
initial_level = True
bbox = self._tile_wgs_bbox(tile_coord, layer.grid, limit=True)
if bbox is None:
raise RequestError('The requested tile is outside the bounding box '
'of the tile map.', request=map_request)
tile = SubTile(tile_coord, bbox)
subtiles = self._get_subtiles(tile_coord, layer)
tile_size = layer.grid.tile_size[0]
url = map_request.http.script_url.rstrip('/')
result = KMLRenderer().render(tile=tile, subtiles=subtiles, layer=layer,
url=url, name=map_request.layer, format=layer.format, name_path=layer.md['name_path'],
initial_level=initial_level, tile_size=tile_size)
resp = Response(result, content_type='application/vnd.google-earth.kml+xml')
resp.cache_headers(etag_data=(result,), max_age=self.max_tile_age)
resp.make_conditional(map_request.http)
return resp
def map(self, tile_request):
"""
:return: the requested tile
:rtype: Response
"""
if self.origin and not tile_request.origin:
tile_request.origin = self.origin
layer, limit_to = self.layer(tile_request)
def decorate_img(image):
query_extent = (layer.grid.srs.srs_code,
layer.tile_bbox(tile_request, use_profiles=tile_request.use_profiles))
return self.decorate_img(image, 'tms', [layer.name], tile_request.http.environ, query_extent)
tile = layer.render(tile_request, use_profiles=tile_request.use_profiles, coverage=limit_to, decorate_img=decorate_img)
tile_format = getattr(tile, 'format', tile_request.format)
resp = Response(tile.as_buffer(), content_type='image/' + tile_format)
if tile.cacheable:
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
else:
resp.cache_headers(no_cache=True)
resp.make_conditional(tile_request.http)
return resp
def map(self, tile_request):
"""
:return: the requested tile
:rtype: Response
"""
if self.origin and not tile_request.origin:
tile_request.origin = self.origin
layer, limit_to = self.layer(tile_request)
def decorate_img(image):
query_extent = (layer.grid.srs.srs_code,
layer.tile_bbox(
tile_request,
use_profiles=tile_request.use_profiles))
return self.decorate_img(image, 'tms', [layer.name],
tile_request.http.environ, query_extent)
tile = layer.render(tile_request,
use_profiles=tile_request.use_profiles,
coverage=limit_to,
decorate_img=decorate_img)
tile_format = getattr(tile, 'format', tile_request.format)
resp = Response(tile.as_buffer(), content_type='image/' + tile_format)
if tile.cacheable:
resp.cache_headers(tile.timestamp,
etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
else:
resp.cache_headers(no_cache=True)
resp.make_conditional(tile_request.http)
return resp
def tile(self, request):
self.check_request(request)
tile_layer = self.layers[request.layer][request.tilematrixset]
if not request.format:
request.format = tile_layer.format
self.check_request_dimensions(tile_layer, request)
limited_to = self.authorize_tile_layer(tile_layer, request)
def decorate_img(image):
query_extent = tile_layer.grid.srs.srs_code, tile_layer.tile_bbox(
request)
return self.decorate_img(image, 'wmts', [tile_layer.name],
request.http.environ, query_extent)
tile = tile_layer.render(request,
coverage=limited_to,
decorate_img=decorate_img)
# set the content_type to tile.format and not to request.format ( to support mixed_mode)
resp = Response(tile.as_buffer(), content_type='image/' + tile.format)
resp.cache_headers(tile.timestamp,
etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
resp.make_conditional(request.http)
return resp
def kml(self, map_request):
"""
:return: the rendered KML response
"""
layer = self.layer(map_request)
self.authorize_tile_layer(layer.name, map_request.http.environ)
tile_coord = map_request.tile
initial_level = False
if tile_coord[2] == 0:
initial_level = True
bbox = self._tile_wgs_bbox(tile_coord, layer.grid, limit=True)
if bbox is None:
raise RequestError('The requested tile is outside the bounding box '
'of the tile map.', request=map_request)
tile = SubTile(tile_coord, bbox)
subtiles = self._get_subtiles(tile_coord, layer)
tile_size = layer.grid.tile_size[0]
url = map_request.http.script_url.rstrip('/')
result = KMLRenderer().render(tile=tile, subtiles=subtiles, layer=layer,
url=url, name=map_request.layer, format=layer.format, name_path=layer.md['name_path'],
initial_level=initial_level, tile_size=tile_size)
resp = Response(result, content_type='application/vnd.google-earth.kml+xml')
resp.cache_headers(etag_data=(result,), max_age=self.max_tile_age)
resp.make_conditional(map_request.http)
return resp
def tile(self, request):
self.check_request(request)
tile_layer = self.layers[request.layer][request.tilematrixset]
if not request.format:
request.format = tile_layer.format
tile = tile_layer.render(request)
resp = Response(tile.as_buffer(), content_type='image/' + request.format)
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
resp.make_conditional(request.http)
return resp
def tile(self, request):
self.check_request(request)
tile_layer = self.layers[request.layer][request.tilematrixset]
if not request.format:
request.format = tile_layer.format
limited_to = self.authorize_tile_layer(tile_layer, request)
tile = tile_layer.render(request, coverage=limited_to)
# set the content_type to tile.format and not to request.format ( to support mixed_mode)
resp = Response(tile.as_buffer(), content_type="image/" + tile.format)
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size), max_age=self.max_tile_age)
resp.make_conditional(request.http)
return resp
def tile(self, request):
self.check_request(request)
tile_layer = self.layers[request.layer][request.tilematrixset]
if not request.format:
request.format = tile_layer.format
tile = tile_layer.render(request)
# set the content_type to tile.format and not to request.format ( to support mixed_mode)
resp = Response(tile.as_buffer(), content_type='image/' + tile.format)
resp.cache_headers(tile.timestamp,
etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
resp.make_conditional(request.http)
return resp
def map(self, map_request):
"""
:return: the requested tile
"""
# force 'sw' origin for kml
map_request.origin = 'sw'
layer = self.layer(map_request)
self.authorize_tile_layer(layer.name, map_request.http.environ)
tile = layer.render(map_request)
resp = Response(tile.as_buffer(),
content_type='image/' + map_request.format)
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
resp.make_conditional(map_request.http)
return resp
def render(self):
"""
Return a response with the rendered exception.
The rendering is delegated to the ``exception_handler`` that issued
the ``RequestError``.
:rtype: `Response`
"""
if self.request is not None:
handler = self.request.exception_handler
resp = handler.render(self)
elif self.status is not None:
resp = Response(self.msg, status=self.status)
else:
resp = Response('internal error: %s' % self.msg, status=500)
resp.cache_headers(no_cache=True)
return resp
def map(self, tile_request):
"""
:return: the requested tile
:rtype: Response
"""
if self.origin and not tile_request.origin:
tile_request.origin = self.origin
layer = self.layer(tile_request)
tile = layer.render(tile_request, use_profiles=tile_request.use_profiles)
resp = Response(tile.as_buffer(), content_type='image/' + tile_request.format)
if tile.cacheable:
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
else:
resp.cache_headers(no_cache=True)
resp.make_conditional(tile_request.http)
return resp
def map(self, tile_request):
"""
:return: the requested tile
:rtype: Response
"""
if self.origin and not tile_request.origin:
tile_request.origin = self.origin
layer = self.layer(tile_request)
tile = layer.render(tile_request,
use_profiles=tile_request.use_profiles)
tile_format = getattr(tile, 'format', tile_request.format)
resp = Response(tile.as_buffer(), content_type='image/' + tile_format)
if tile.cacheable:
resp.cache_headers(tile.timestamp,
etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
else:
resp.cache_headers(no_cache=True)
resp.make_conditional(tile_request.http)
return resp
def tile(self, request):
self.check_request(request)
tile_layer = self.layers[request.layer][request.tilematrixset]
if not request.format:
request.format = tile_layer.format
self.check_request_dimensions(tile_layer, request)
limited_to = self.authorize_tile_layer(tile_layer, request)
def decorate_img(image):
query_extent = tile_layer.grid.srs.srs_code, tile_layer.tile_bbox(request)
return self.decorate_img(image, 'wmts', [tile_layer.name], request.http.environ, query_extent)
tile = tile_layer.render(request, coverage=limited_to, decorate_img=decorate_img)
# set the content_type to tile.format and not to request.format ( to support mixed_mode)
resp = Response(tile.as_buffer(), content_type='image/' + tile.format)
resp.cache_headers(tile.timestamp, etag_data=(tile.timestamp, tile.size),
max_age=self.max_tile_age)
resp.make_conditional(request.http)
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
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
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
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
