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 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