def test_unsupported(self):
assert (
limit_srs_extents(
{"EPSG:9999": DefaultMapExtent()}, ["EPSG:4326", "EPSG:3857"]
)
== {}
)
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 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)),
})
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, 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 __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()
class DummyLayer(MapLayer):
transparent = True
extent = DefaultMapExtent()
has_legend = False
queryable = False
def __init__(self, name):
MapLayer.__init__(self)
self.name = name
self.requested = False
self.queried = False
def get_map(self, query):
self.requested = True
def get_info(self, query):
self.queried = True
def map_layers_for_query(self, query):
return [(self.name, self)]
def info_layers_for_query(self, query):
return [(self.name, self)]
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()
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 __init__(self):
MapLayer.__init__(self)
self.extent = DefaultMapExtent()
self.res_range = None
def test_unsupported(self):
eq_(
limit_srs_extents({'EPSG:9999': DefaultMapExtent()},
['EPSG:4326', 'EPSG:3857']), {})
def test_defaults(self):
eq_(limit_srs_extents({}, ['EPSG:4326', 'EPSG:3857']), {
'EPSG:4326': DefaultMapExtent(),
'EPSG:3857': DefaultMapExtent(),
})
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 test_defaults(self):
assert limit_srs_extents({}, ["EPSG:4326", "EPSG:3857"]) == {
"EPSG:4326": DefaultMapExtent(),
"EPSG:3857": DefaultMapExtent(),
}
@cached_property
def layers(self):
layers = []
for layer in self.root_layer.layers:
if not layer.name or self.layer_permitted(layer):
filtered_layer = FilteredRootLayer(layer, self.permissions,
self.coverage)
if filtered_layer.is_active or filtered_layer.layers:
# add filtered_layer only if it is active (no grouping layer)
# or if it contains other active layers
layers.append(filtered_layer)
return layers
DEFAULT_EXTENTS = {
'EPSG:3857': DefaultMapExtent(),
'EPSG:4326': DefaultMapExtent(),
'EPSG:900913': DefaultMapExtent(),
}
def limit_srs_extents(srs_extents, supported_srs):
"""
Limit srs_extents to supported_srs.
"""
if srs_extents:
srs_extents = srs_extents.copy()
else:
srs_extents = DEFAULT_EXTENTS.copy()
for srs in list(srs_extents.keys()):
def __init__(self):
Source.__init__(self)
self.extent = DefaultMapExtent()
self.transparent = True
self.res_range = None
