def test_wmts_rest_only():
# ServiceMetadata
wmts = WebMapTileService(SERVICE_URL)
assert wmts.identification.type == 'OGC WMTS'
assert wmts.identification.version == '1.0.0'
assert wmts.identification.title == 'WMTS-Testserver DOP80'
# Content
assert sorted(list(wmts.contents)) == ['dop80']
# RESTful WMTS
assert wmts.restonly
resource = wmts.buildTileResource(layer='dop80',
tilematrixset='webmercator',
tilematrix='11',
row='706',
column='1089')
assert resource == 'http://geoserv.weichand.de/mapproxy/wmts/dop80/webmercator/11/1089/706.png'
tile = wmts.gettile(layer='dop80',
tilematrixset='webmercator',
tilematrix='11',
row='706',
column='1089')
out = open(scratch_file('bvv_bayern_dop80.png'), 'wb')
bytes_written = out.write(tile.read())
out.close()
def wmtsRequest(self, layer='AGRICULTURE'):
self.layer = layer
ID = 'your ID'
wmts_url = 'https://services.sentinel-hub.com/ogc/wmts/'+ID
wmts = WebMapTileService(wmts_url)
self.x, self.y = self.deg2num(self.lat_center, self.lon_center, self.zoom)
self.wmtsOut = wmts.gettile(layer=self.layer,
tilematrixset='PopularWebMercator256',
tilematrix=self.zoom,
row=self.y,
column=self.x,
format="image/png")
self.imgArr = imread(io.BytesIO(wmtsOut.read()))
self.lat_max, self.lon_min = self.num2deg(self.x, self.y, self.zoom)
self.lat_min, self.lon_max = self.num2deg(self.x+1, self.y+1, self.zoom)
imgurl = image_to_url(image=self.imgArr)
self.map.add_layer(ImageOverlay(url=imgurl,
bounds=[[self.lat_min, self.lon_min],
[self.lat_max, self.lon_max]]))
def test_wmts():
# Find out what a WMTS has to offer. Service metadata:
from owslib.wmts import WebMapTileService
wmts = WebMapTileService(SERVICE_URL)
assert wmts.identification.type == 'OGC WMTS'
assert wmts.identification.version == '1.0.0'
assert wmts.identification.title == 'NASA Global Imagery Browse Services for EOSDIS'
bytearray(wmts.identification.abstract, 'utf-8')
bytearray(b'Near real time imagery from multiple NASA instruments')
assert wmts.identification.keywords == ['World', 'Global']
# Service Provider:
assert wmts.provider.name == 'National Aeronautics and Space Administration'
assert wmts.provider.url == 'https://earthdata.nasa.gov/'
# Available Layers:
assert len(wmts.contents.keys()) > 0
assert sorted(list(wmts.contents))[0] == 'AIRS_All_Sky_Outgoing_Longwave_Radiation_Daily_Day'
# Fetch a tile (using some defaults):
tile = wmts.gettile(layer='MODIS_Terra_CorrectedReflectance_TrueColor',
tilematrixset='EPSG4326_250m', tilematrix='0',
row=0, column=0, format="image/jpeg")
out = open(scratch_file('nasa_modis_terra_truecolour.jpg'), 'wb')
bytes_written = out.write(tile.read())
out.close()
# Test styles for several layers
# TODO: fix dict order
# assert wmts.contents['MLS_SO2_147hPa_Night'].styles == {'default': {'isDefault': True, 'title': 'default'}}
assert wmts.contents['MLS_SO2_147hPa_Night'].styles['default']['isDefault'] is True
# assert wmts.contents['MLS_SO2_147hPa_Night'].styles == {'default': {'isDefault': True, 'title': 'default'}}
assert wmts.contents['MLS_SO2_147hPa_Night'].styles['default']['isDefault'] is True
def test_wmts():
# Find out what a WMTS has to offer. Service metadata:
from owslib.wmts import WebMapTileService
wmts = WebMapTileService(SERVICE_URL)
assert wmts.identification.type == 'OGC WMTS'
assert wmts.identification.version == '1.0.0'
assert wmts.identification.title == 'NASA Global Imagery Browse Services for EOSDIS'
bytearray(wmts.identification.abstract, 'utf-8')
bytearray(b'Near real time imagery from multiple NASA instruments')
assert wmts.identification.keywords == ['World', 'Global']
# Service Provider:
assert wmts.provider.name == 'National Aeronautics and Space Administration'
assert wmts.provider.url == 'https://earthdata.nasa.gov/'
# Available Layers:
assert len(wmts.contents.keys()) > 0
assert sorted(list(wmts.contents))[0] == 'AIRS_CO_Total_Column_Day'
# Fetch a tile (using some defaults):
tile = wmts.gettile(layer='MODIS_Terra_CorrectedReflectance_TrueColor',
tilematrixset='EPSG4326_250m',
tilematrix='0',
row=0,
column=0,
format="image/jpeg")
out = open(scratch_file('nasa_modis_terra_truecolour.jpg'), 'wb')
bytes_written = out.write(tile.read())
out.close()
# Test styles for several layers
# TODO: fix dict order
# assert wmts.contents['MLS_SO2_147hPa_Night'].styles == {'default': {'isDefault': True, 'title': 'default'}}
assert wmts.contents['MLS_SO2_147hPa_Night'].styles['default'][
'isDefault'] is True
# assert wmts.contents['MLS_SO2_147hPa_Night'].styles == {'default': {'isDefault': True, 'title': 'default'}}
assert wmts.contents['MLS_SO2_147hPa_Night'].styles['default'][
'isDefault'] is True
def test_wmts_rest_only():
# Test a WMTS with REST only
from owslib.wmts import WebMapTileService
wmts = WebMapTileService(SERVICE_URL_REST)
tile = wmts.gettile(layer="bmaporthofoto30cm",
tilematrix="10",
row=357,
column=547)
assert (tile.info()['Content-Type'] == 'image/jpeg')
def __init__(self,
wmts,
layer=None,
tms=None,
tm=None,
fmt=None,
pixel_size=_PIXEL_SIZE):
# Web Map Tile Service
self.wmts = WebMapTileService(wmts)
if layer is None:
layer = next(iter(self.wmts.contents))
self.layer = self.wmts.contents[layer]
if tms is None:
tms = next(iter(self.wmts.tilematrixsets))
self.tms = self.wmts.tilematrixsets[tms]
if tm is None:
tm = next(iter(self.tms.tilematrix))
self.tm = self.tms.tilematrix[tm]
# CRS
self.crs = pp.CRS.from_user_input(self.tms.crs)
self.epsg = ':'.join(self.crs.to_authority())
self._from_wgs = pp.Transformer.from_crs(_WGS84, self.crs)
self._to_wgs = pp.Transformer.from_crs(self.crs, _WGS84)
self.unit = self.crs.coordinate_system.axis_list[0].unit_name
self.ucf = self.crs.coordinate_system.axis_list[
0].unit_conversion_factor
# Tile span(s)
self.pixel_size = pixel_size
self.scale = self.tm.scaledenominator
self.pixel_span = self.scale * self.pixel_size * self.ucf
self.tile_width = self.tm.tilewidth
self.tile_height = self.tm.tileheight
self.tile_span_x = self.tile_width * self.pixel_span
self.tile_span_y = self.tile_height * self.pixel_span
# Domain
self.matrix_width = self.tm.matrixwidth
self.matrix_height = self.tm.matrixheight
self.x_min, self.y_max = self.tm.topleftcorner
self.x_max = self.x_min + self.matrix_width * self.tile_span_x
self.y_min = self.y_max - self.matrix_height * self.tile_span_y
# Format
self.fmt = self.layer.formats[0] if fmt is None else fmt
def test_wmts_example_build_tile_request():
"""
Example for wmts.buildTileRequest
"""
wmts = WebMapTileService(SERVICE_URL)
wmts.buildTileRequest(layer='VIIRS_CityLights_2012',
tilematrixset='EPSG4326_500m',
tilematrix='6',
row=4,
column=4)
request = 'SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&\
def test_wmts_example_get_title():
"""
Example for wmts.getTitle
"""
wmts = WebMapTileService(SERVICE_URL)
img = wmts.gettile(layer='VIIRS_CityLights_2012',
tilematrixset='EPSG4326_500m',
tilematrix='6',
row=4,
column=4)
out = open('tile.jpg', 'wb')
bytes_written = out.write(img.read())
out.close()
def get_map(lon_min, lon_max, lat_min, lat_max, zoom=19):
"""
Get an ESRI World Imagery map of the selected region
Args:
lon_min: Minimum longitude (degrees)
lon_max: Maximum longitude (degrees)
lat_min: Minimum latitude (degrees)
lat_max: Maximum latitude (degrees)
zoom: Zoom level
Returns:
np.array: Numpy array which can be plotted with plt.imshow
"""
upperleft_tile = mercantile.tile(lon_min, lat_max, zoom)
xmin, ymin = upperleft_tile.x, upperleft_tile.y
lowerright_tile = mercantile.tile(lon_max, lat_min, zoom)
xmax, ymax = lowerright_tile.x, lowerright_tile.y
total_image = np.zeros([256 * (ymax - ymin + 1), 256 * (xmax - xmin + 1), 3], dtype='uint8')
os.makedirs("tilecache", exist_ok=True)
tile_min = mercantile.tile(lon_min, lat_min, zoom)
tile_max = mercantile.tile(lon_max, lat_max, zoom)
wmts = WebMapTileService("http://server.arcgisonline.com/arcgis/rest/" +
"services/World_Imagery/MapServer/WMTS/1.0.0/WMTSCapabilities.xml")
for x in range(tile_min.x, tile_max.x + 1):
for y in range(tile_max.y, tile_min.y + 1):
tilename = os.path.join("tilecache", f"World_Imagery_{zoom}_{x}_{y}.jpg")
if not os.path.isfile(tilename):
tile = wmts.gettile(layer="World_Imagery", tilematrix=str(zoom), row=y, column=x)
out = open(tilename, "wb")
out.write(tile.read())
out.close()
tile_image = imread(tilename)
total_image[(y - ymin) * 256: (y - ymin + 1) * 256,
(x - xmin) * 256: (x - xmin + 1) * 256] = tile_image
total_llmin = {'lon': mercantile.bounds(xmin, ymax, zoom).west, 'lat': mercantile.bounds(xmin, ymax, zoom).south}
total_llmax = {'lon': mercantile.bounds(xmax, ymin, zoom).east, 'lat': mercantile.bounds(xmax, ymin, zoom).north}
pix_xmin = int(round(np.interp(lon_min, [total_llmin['lon'], total_llmax['lon']], [0, total_image.shape[1]])))
pix_ymin = int(round(np.interp(lat_min, [total_llmin['lat'], total_llmax['lat']], [0, total_image.shape[0]])))
pix_xmax = int(round(np.interp(lon_max, [total_llmin['lon'], total_llmax['lon']], [0, total_image.shape[1]])))
pix_ymax = int(round(np.interp(lat_max, [total_llmin['lat'], total_llmax['lat']], [0, total_image.shape[0]])))
return total_image[total_image.shape[0] - pix_ymax: total_image.shape[0] - pix_ymin, pix_xmin: pix_xmax]
def test_wmts_gettile(ows_server):
wmts = WebMapTileService(url=ows_server.url + "/wmts")
contents = list(wmts.contents)
test_layer_name = contents[0]
tile = wmts.gettile(layer=test_layer_name,
tilematrixset='WholeWorld_WebMercator',
tilematrix='0',
row=0,
column=0,
format="image/png")
assert tile
assert tile.info()['Content-Type'] == 'image/png'
def update_layers_wmts(service):
"""
Update layers for an OGC_WMTS service.
"""
wmts = WebMapTileService(service.url)
layer_names = list(wmts.contents)
for layer_name in layer_names:
ows_layer = wmts.contents[layer_name]
print 'Updating layer %s' % ows_layer.name
layer, created = Layer.objects.get_or_create(name=ows_layer.name,
service=service)
if layer.active:
layer.title = ows_layer.title
layer.abstract = ows_layer.abstract
layer.url = service.url
layer.page_url = reverse('layer_detail',
kwargs={'layer_id': layer.id})
bbox = list(ows_layer.boundingBoxWGS84
or (-179.0, -89.0, 179.0, 89.0))
layer.bbox_x0 = bbox[0]
layer.bbox_y0 = bbox[1]
layer.bbox_x1 = bbox[2]
layer.bbox_y1 = bbox[3]
layer.save()
# dates
add_mined_dates(layer)
def check_wmts(source, info_msgs, warning_msgs, error_msgs):
"""
Check WMTS source
Parameters
----------
source : dict
Source dictionary
info_msgs : list
Good messages
warning_msgs: list
Warning messages
error_msgs: list:
Error Messages
"""
try:
wmts_url = source['properties']['url']
if not validators.url(wmts_url):
error_msgs.append("URL validation error: {}".format(wmts_url))
with warnings.catch_warnings():
warnings.simplefilter("ignore")
wmts = WebMapTileService(wmts_url)
except Exception as e:
error_msgs.append("Exception: {}".format(str(e)))
def get_wmts_cap(result):
def convert_layer(lyr):
return {
"name": lyr,
"title": wmts[lyr].title,
"tilematrixsets": ",".join(list(wmts[lyr].tilematrixsetlinks.keys())),
"imgformats": ",".join(wmts[lyr].formats),
}
try:
url = result["url"]
md_id = result["mdId"]
wmts = WebMapTileService(url)
title = wmts.identification.title
abstract = wmts.identification.abstract
keywords = wmts.identification.keywords
layers = list(wmts.contents)
result["title"] = title
result["abstract"] = abstract
result["layers"] = list(map(convert_layer, layers))
result["keywords"] = keywords
except Exception:
message = f"exception while retrieving WMTS cap for service mdId: {md_id}, url: {url}"
logging.exception(message)
return result
def request(self, service):
try:
if service == 'WMS':
self.resp['resp'] = WebMapService(
"https://data.linz.govt.nz/services;"
"key=" + self.key + "/wms/",
version='1.1.1')
return
if service == 'WMTS':
self.resp['resp'] = WebMapTileService(
"https://data.linz.govt.nz/services;"
"key=" + self.key + "/wmts/1.0.0/WMTSCapabilities.xml?"
"count=10",
version='1.0.0')
return
if service == 'WFS':
self.resp['resp'] = WebFeatureService(
"https://data.linz.govt.nz/services;"
"key=" + self.key + "/wfs/?"
"service=WFS&"
"request=GetCapabilities",
version='1.1.0')
return
except:
self.resp[
'err'] = "ERROR: Something went wrong with the request. Timeout? Incorrect API KEY?"
def connectToDGTile(config):
return WebMapTileService(
"https://evwhs.digitalglobe.com/earthservice/wmtsaccess?connectid=" +
config['connectid'],
username=config['uname'],
password=config['passwd'],
version='1.1.1')
def test_wmts_gettile_wkss(ows_server):
wmts = WebMapTileService(url=ows_server.url + "/wmts")
contents = list(wmts.contents)
test_layer_name = contents[0]
tile = wmts.gettile(
layer=test_layer_name,
tilematrixset="urn:ogc:def:wkss:OGC:1.0:GoogleMapsCompatible",
tilematrix="0",
row=0,
column=0,
format="image/png",
)
assert tile
assert tile.info()["Content-Type"] == "image/png"
def test_wmts_gettile_exception(ows_server):
wmts = WebMapTileService(url=ows_server.url + "/wmts")
contents = list(wmts.contents)
test_layer_name = contents[0]
try:
# supplying an unsupported tilematrixset
wmts.gettile(layer=test_layer_name,
tilematrixset='WholeWorld_WebMercatorxxx',
tilematrix='0',
row=0,
column=0,
format="image/png")
except ServiceException as e:
assert 'Invalid Tile Matrix Set:' in str(e)
else:
assert False
def test_wmts_server(ows_server):
# Use owslib to confirm that we have a somewhat compliant WCS service
wmts = WebMapTileService(url=ows_server.url + "/wmts")
assert wmts.identification.type == "OGC WMTS"
assert wmts.identification.version == "1.0.0"
# Ensure that we have at least some layers available
contents = list(wmts.contents)
assert contents
def __init__(self, url: str, layer: str, tile_system: str,
tile_level: Union[str, int], format: str) -> None:
"""Creates a tile matrix (WMTS layer at fixed zoom level).
Args:
url: The URL to the Web Map Tile Service (WMTS).
layer: The WMTS layer name.
tile_system: Name of the tile system (should use the
Rijksdriehoek coordinate system, or at least use 1-metre
units).
tile_level: The zoom level.
format: The image format for tiles. Usually either
`image/png` or `image/jpeg`.
"""
self.wmts = WebMapTileService(url)
self.layer = layer
self.tile_system = tile_system
self.tile_level = str(tile_level)
self.format = format
assert layer in self.wmts.contents, \
'Layer not found.'
assert tile_system in self.wmts.tilematrixsets, \
'Tile matrix set not found.'
assert tile_system in self.wmts.contents[layer].tilematrixsetlinks, \
'Tile system not found.'
assert format in self.wmts.contents[layer].formats, \
'Unsupported format.'
# See: pdf, pp. 8-9
# (Top left corner is min x and max y.)
# Note: Rijksdriehoek metric is in metres. This is relevant
# because the scaling parameter has been omitted for this
# reason.
self.matrix = (
self.wmts.tilematrixsets[tile_system].tilematrix[str(tile_level)])
self.pixel_span = self.matrix.scaledenominator * 0.28 * 1e-3
self.span_x = self.matrix.tilewidth * self.pixel_span
self.span_y = self.matrix.tileheight * self.pixel_span
async def check_wmts(source, session):
"""
Check WMTS source
Parameters
----------
source : dict
Source dictionary
session : ClientSession
aiohttp ClientSession object
Returns
-------
list:
Good messages
list:
Warning messages
list:
Error Messages
"""
error_msgs = []
warning_msgs = []
info_msgs = []
try:
wmts_url = source["properties"]["url"]
headers = get_http_headers(source)
if not validators.url(wmts_url):
error_msgs.append("URL validation error: {}".format(wmts_url))
with warnings.catch_warnings():
warnings.simplefilter("ignore")
response = await get_url(wmts_url,
session,
with_text=True,
headers=headers)
if response.exception is not None:
error_msgs.append(response.exception)
return info_msgs, warning_msgs, error_msgs
xml = response.text
wmts = WebMapTileService(wmts_url, xml=xml.encode("utf-8"))
info_msgs.append("Good")
except Exception as e:
error_msgs.append("Exception: {}".format(str(e)))
return info_msgs, warning_msgs, error_msgs
def doWmts(url):
wmts = WebMapTileService(url)
## Huom! Katsoin mitä QGIS tallentaa WMTS "sourceen" ja siellä näkyy olevan GetCapaiblities-osoite
wmtsGetCaps = next(
(i for i in wmts.getOperationByName('GetCapabilities').methods
if i['type'] == 'Get'), None)
return {
'type':
'WMTS',
'contents':
list(wmts.contents),
'formatPerLayer':
dict(map(lambda kv: (kv[0], kv[1].formats), wmts.contents.items())),
'tileMatrixSetsPerLayer':
dict(
map(lambda kv: (kv[0], kv[1].tilematrixsets),
wmts.contents.items())),
'url':
wmtsGetCaps['url'],
'service':
wmts
}
def mundi_wmts(self,
dataset: str,
version: str = "1.0.0") -> WebMapTileService:
"""
Get a WebMapTileService instance for this collection
:param dataset: the target dataset (eg, "L1C" if collection is "Sentinel1"
:param version: WMTS version (only 1.0.0 is supported)
:return: a WebMapTileService instance
"""
if version in ["1.0.0"]:
return WebMapTileService(self._service_end_point('wmts', dataset),
version)
else:
raise MundiException(ErrorMessages.UNSUPPORTED_SERVICE)
def test_wmts_tile_caching():
image_cache = WMTSRasterSource._shared_image_cache
image_cache.clear()
assert len(image_cache) == 0
url = 'https://map1c.vis.earthdata.nasa.gov/wmts-geo/wmts.cgi'
wmts = WebMapTileService(url)
layer_name = 'MODIS_Terra_CorrectedReflectance_TrueColor'
source = WMTSRasterSource(wmts, layer_name)
gettile_counter = CallCounter(wmts, 'gettile')
crs = ccrs.PlateCarree()
extent = (-180, 180, -90, 90)
resolution = (20, 10)
with gettile_counter:
source.fetch_raster(crs, extent, resolution)
n_tiles = 2
assert gettile_counter.count == n_tiles, ('Too many tile requests - '
'expected {}, got {}.'.format(
n_tiles,
gettile_counter.count)
)
gc.collect()
assert len(image_cache) == 1
assert len(image_cache[wmts]) == 1
tiles_key = (layer_name, '0')
assert len(image_cache[wmts][tiles_key]) == n_tiles
# Second time around we shouldn't request any more tiles so the
# call count will stay the same.
with gettile_counter:
source.fetch_raster(crs, extent, resolution)
assert gettile_counter.count == n_tiles, ('Too many tile requests - '
'expected {}, got {}.'.format(
n_tiles,
gettile_counter.count)
)
gc.collect()
assert len(image_cache) == 1
assert len(image_cache[wmts]) == 1
tiles_key = (layer_name, '0')
assert len(image_cache[wmts][tiles_key]) == n_tiles
# Once there are no live references the weak-ref cache should clear.
del source, wmts, gettile_counter
gc.collect()
assert len(image_cache) == 0
def update_layers_wmts(service):
"""
Update layers for an OGC:WMTS service.
"""
wmts = WebMapTileService(service.url)
layer_names = list(wmts.contents)
for layer_name in layer_names:
ows_layer = wmts.contents[layer_name]
print 'Updating layer %s' % ows_layer.name
layer, created = Layer.objects.get_or_create(name=ows_layer.name, service=service)
if layer.active:
links = [['OGC:WMTS', service.url]]
layer.type = 'OGC:WMTS'
layer.title = ows_layer.title
layer.abstract = ows_layer.abstract
# keywords
for keyword in ows_layer.keywords:
layer.keywords.add(keyword)
layer.url = service.url
layer.page_url = reverse('layer_detail', kwargs={'layer_id': layer.id})
links.append([
'WWW:LINK',
settings.SITE_URL.rstrip('/') + layer.page_url
])
bbox = list(ows_layer.boundingBoxWGS84 or (-179.0, -89.0, 179.0, 89.0))
layer.bbox_x0 = bbox[0]
layer.bbox_y0 = bbox[1]
layer.bbox_x1 = bbox[2]
layer.bbox_y1 = bbox[3]
layer.wkt_geometry = bbox2wktpolygon(bbox)
layer.xml = create_metadata_record(
identifier=layer.id_string,
source=service.url,
links=links,
format='OGC:WMS',
type=layer.csw_type,
relation=service.id_string,
title=ows_layer.title,
alternative=ows_layer.name,
abstract=layer.abstract,
keywords=ows_layer.keywords,
wkt_geometry=layer.wkt_geometry
)
layer.anytext = gen_anytext(layer.title, layer.abstract, ows_layer.keywords)
layer.save()
# dates
add_mined_dates(layer)
def get_service_obj(self):
try:
if self.service == "wmts":
self.obj = WebMapTileService(
url=None,
xml=self.xml,
version=self.version,
)
elif self.service == "wfs":
self.obj = WebFeatureService(
url=None,
xml=self.xml,
version=self.version,
)
except XMLSyntaxError:
# most likely the locally stored xml is corrupt
self.err = "{0}: XMLSyntaxError".format(self.domain)
def test_wmts_tile_caching():
image_cache = WMTSRasterSource._shared_image_cache
image_cache.clear()
assert len(image_cache) == 0
url = 'https://map1c.vis.earthdata.nasa.gov/wmts-geo/wmts.cgi'
wmts = WebMapTileService(url)
layer_name = 'MODIS_Terra_CorrectedReflectance_TrueColor'
source = WMTSRasterSource(wmts, layer_name)
crs = ccrs.PlateCarree()
extent = (-180, 180, -90, 90)
resolution = (20, 10)
n_tiles = 2
with mock.patch.object(wmts, 'gettile',
wraps=wmts.gettile) as gettile_counter:
source.fetch_raster(crs, extent, resolution)
assert gettile_counter.call_count == n_tiles, (
f'Too many tile requests - expected {n_tiles}, got '
f'{gettile_counter.call_count}.')
del gettile_counter
gc.collect()
assert len(image_cache) == 1
assert len(image_cache[wmts]) == 1
tiles_key = (layer_name, '0')
assert len(image_cache[wmts][tiles_key]) == n_tiles
# Second time around we shouldn't request any more tiles.
with mock.patch.object(wmts, 'gettile',
wraps=wmts.gettile) as gettile_counter:
source.fetch_raster(crs, extent, resolution)
gettile_counter.assert_not_called()
del gettile_counter
gc.collect()
assert len(image_cache) == 1
assert len(image_cache[wmts]) == 1
tiles_key = (layer_name, '0')
assert len(image_cache[wmts][tiles_key]) == n_tiles
# Once there are no live references the weak-ref cache should clear.
del source, wmts
gc.collect()
assert len(image_cache) == 0
def loadServiceList(self, service_id: int):
self.iFace.messageBar().pushMessage('Info: ', 'Please wait loading layers ... ', level=Qgis.Info)
self.bar.show()
self.iFace.mainWindow().repaint()
self.generatedService = WebMapServiceClass(service_id)
url = self.generatedService.service_url
if self.generatedService.service_type == ServiceType.WebMapService.value:
try:
wms = WebMapService(url)
self.generatedService.setWebMapService(wms)
except Exception as e:
QMessageBox.information(None, "ERROR:", 'Unable to load this service now.' + str(e))
elif self.generatedService.service_type == ServiceType.WebMapTileService.value:
try:
wmts = WebMapTileService(url)
self.generatedService.setWebMapService(wmts)
except Exception as e:
QMessageBox.information(None, "ERROR:", 'Unable to load this service now.' + str(e))
self.bar.close()
def main():
# URL of NASA GIBS
URL = 'http://gibs.earthdata.nasa.gov/wmts/epsg4326/best/wmts.cgi'
wmts = WebMapTileService(URL)
# Layers for MODIS true color and snow RGB
layers = [
'MODIS_Terra_SurfaceReflectance_Bands143',
'MODIS_Terra_CorrectedReflectance_Bands367'
]
date_str = '2017-12-07'
# Plot setup
plot_CRS = ccrs.Mercator()
geodetic_CRS = ccrs.Geodetic()
x0, y0 = plot_CRS.transform_point(3.7, 43.9, geodetic_CRS)
x1, y1 = plot_CRS.transform_point(22.5, 50.8, geodetic_CRS)
ysize = 8
xsize = 2 * ysize * (x1 - x0) / (y1 - y0)
fig = plt.figure(figsize=(xsize, ysize), dpi=100)
for layer, offset in zip(layers, [0, 0.5]):
ax = plt.axes([offset, 0, 0.5, 1], projection=plot_CRS)
ax.set_xlim((x0, x1))
ax.set_ylim((y0, y1))
ax.add_wmts(wmts, layer, wmts_kwargs={'time': date_str})
txt = plt.text(4.7,
43.2,
wmts[layer].title,
fontsize=18,
color='wheat',
transform=geodetic_CRS)
txt.set_path_effects(
[PathEffects.withStroke(linewidth=5, foreground='black')])
state_boundaries = feat.NaturalEarthFeature(category='cultural',
name='admin_0_countries',
scale='10m',
facecolor='none')
ax.coastlines(resolution='10m', zorder=1, color='black')
ax.add_feature(state_boundaries, zorder=1, edgecolor='black')
plt.show()
def get_data(self, element, ranges, style):
if WebMapTileService is None:
raise SkipRendering('WMTS element requires owslib and PIL '
'to be installed.')
tile_source = None
for url in element.data:
if isinstance(url, util.basestring):
try:
tile_source = WebMapTileService(url)
break
except:
pass
elif isinstance(url, WebMapTileService):
tile_source = url
break
if tile_source is None:
raise SkipRendering("No valid tile source URL found in WMTS "
"Element, rendering skipped.")
return (tile_source, element.layer), style, {}
def wmts_metadata(wmts_url):
"""Discover what's available"""
from owslib.wmts import WebMapTileService
wmts = WebMapTileService(wmts_url)
tilematrixsets = {}
for identifier, tilematrix in wmts.tilematrixsets.items():
# Store information of identifier and associated crs
zooms = [int(key) for key in tilematrix.tilematrix]
tilematrixsets[identifier] = {
"crs" : tilematrix.crs,
"min_zoom" : min(zooms),
"max_zoom" : max(zooms),
}
provider_metadata = {}
for name, variant in wmts.contents.items():
d = defaultdict(list)
for attribute in ("formats", "layers"):
for key in getattr(variant, attribute):
d[attribute].append(key)
for style in variant.styles:
if style is None:
d["styles"].append("default")
else:
d["styles"].append(style)
for url in variant.resourceURLs:
d["url"].append(url["template"])
for identifier in variant._tilematrixsets:
d["tilematrixset"].append(identifier)
d["bboxWGS84"] = variant.boundingBoxWGS84
provider_metadata[name] = d
return provider_metadata, tilematrixsets
def main_vis():
# URL of NASA GIBS
URL = 'http://gibs.earthdata.nasa.gov/wmts/epsg4326/best/wmts.cgi'
wmts = WebMapTileService(URL)
# Layers for MODIS true color and snow RGB
layers = ['MODIS_Terra_SurfaceReflectance_Bands143']
# 'MODIS_Terra_CorrectedReflectance_Bands367'
date_str = '2017-12-07'
# Plot setup
plot_CRS = ccrs.LambertConformal(central_longitude=13,
central_latitude=46,
standard_parallels=[35])
geodetic_CRS = ccrs.Geodetic()
x0, y0 = plot_CRS.transform_point(3.7, 43.9, geodetic_CRS)
x1, y1 = plot_CRS.transform_point(22.5, 50.8, geodetic_CRS)
ax = plt.axes(projection=plot_CRS)
ax.set_xlim((x0, x1))
ax.set_ylim((y0, y1))
ax.add_wmts(wmts, layers[0], wmts_kwargs={'time': date_str})
def build_wmts_url(self, api_layer, srv_details, rsc_type="ds_dyn_lyr_srv", mode="complete"):
"""Format the input WMTS URL to fit QGIS criterias.
Retrieve GetCapabilities from information transmitted by Isogeo API
to complete URL syntax.
"""
# local variables
layer_name = api_layer.get("id")
layer_title = api_layer.get("titles")[0].get("value", "WMTS Layer")
wmts_url_getcap = srv_details.get("path")\
+ "?request=GetCapabilities&service=WMTS"
geoserver = "geoserver" in wmts_url_getcap
# basic checks on service url
try:
wmts = WebMapTileService(wmts_url_getcap)
except TypeError as e:
logger.error("WMTS - OWSLib mixing str and unicode args", e)
wmts = WebMapTileService(unicode(wmts_url_getcap))
except ServiceException as e:
logger.error(e)
return 0, "WMTS - Bad operation: " + wmts_url_getcap, str(e)
except HTTPError as e:
logger.error(e)
return 0, "WMTS - Service not reached: " + wmts_url_getcap, e
except Exception as e:
logger.error("WMTS - {}: {}".format(wmts_url_getcap, e))
return 0, "WMTS - Service not reached: " + wmts_url_getcap, e
# check if GetTile operation is available
if not hasattr(wmts, "gettile") or "GetTile" not in [op.name for op in wmts.operations]:
return 0, "Required GetTile operation not available in: " + wmts_url_getcap
else:
logger.debug("GetTile available")
pass
# check if layer is present and queryable
try:
wmts_lyr = wmts[layer_name]
layer_title = wmts_lyr.title
layer_id = wmts_lyr.id
except KeyError as e:
logger.error("Layer {} not found in WMTS service: {}"
.format(layer_name,
wmts_url_getcap))
return (0,
"Layer {} not found in WMS service: {}"
.format(layer_name,
wmts_url_getcap), e)
# Tile Matrix Set & SRS
srs_map = plg_tools.get_map_crs()
def_tile_matrix_set = wmts_lyr.tilematrixsets[0]
if srs_map in wmts_lyr.tilematrixsets:
logger.debug("WMTS - It's a SRS match! With map canvas: " + srs_map)
tile_matrix_set = wmts.tilematrixsets.get(srs_map).identifier
srs = srs_map
elif "EPSG:4326" in wmts_lyr.tilematrixsets:
logger.debug("WMTS - It's a SRS match! With standard WGS 84 (4326)")
tile_matrix_set = wmts.tilematrixsets.get("EPSG:4326").identifier
srs = "EPSG:4326"
elif "EPSG:900913" in wmts_lyr.tilematrixsets:
logger.debug("WMTS - It's a SRS match! With Google (900913)")
tile_matrix_set = wmts.tilematrixsets.get("EPSG:900913").identifier
srs = "EPSG:900913"
else:
logger.debug("WMTS - Searched SRS not available within service CRS.")
tile_matrix_set = wmts.tilematrixsets.get(def_tile_matrix_set).identifier
srs = tile_matrix_set
# Format definition
wmts_lyr_formats = wmts.getOperationByName('GetTile').formatOptions
formats_image = [f.split(" ", 1)[0] for f in wmts_lyr_formats
if f in qgis_wms_formats]
if len(formats_image):
if "image/png" in formats_image:
layer_format = "image/png"
elif "image/jpeg" in formats_image:
layer_format = "image/jpeg"
else:
layer_format = formats_image[0]
else:
logger.debug("WMTS - No format available among preferred by QGIS.")
layer_format = "image/png"
# Style definition
lyr_style = wmts_lyr.styles.keys()[0]
# GetTile URL
wmts_lyr_url = wmts.getOperationByName('GetTile').methods
wmts_lyr_url = wmts_lyr_url[0].get("url")
if wmts_lyr_url[-1] == "&":
wmts_lyr_url = wmts_lyr_url[:-1]
else:
pass
# construct URL
wmts_url_params = {"SERVICE": "WMTS",
"VERSION": "1.0.0",
"REQUEST": "GetCapabilities",
"layers": layer_id,
"crs": srs,
"format": layer_format,
"styles": "",
"tileMatrixSet": tile_matrix_set,
"url": wmts_lyr_url,
}
wmts_url_final = unquote(urlencode(wmts_url_params, "utf8"))
logger.debug(wmts_url_final)
# method ending
return ["WMTS", layer_title, wmts_url_final]
def process_wmts_service(url, name, type, username, password, wmts=None, owner=None, parent=None):
"""
Create a new WMTS service
"""
if wmts is None:
wmts = WebMapTileService(url)
try:
base_url = _clean_url(wmts.getOperationByName("GetTile").methods["Get"]["url"])
if base_url and base_url != url:
url = base_url
wmts = WebMapTileService(base_url)
except:
logger.info("Could not retrieve GetMap url, using originally supplied URL %s" % url)
pass
try:
service = Service.objects.get(base_url=url)
return_dict = [
{
"status": "ok",
"msg": _("This is an existing service"),
"service_id": service.pk,
"service_name": service.name,
"service_title": service.title,
}
]
return HttpResponse(json.dumps(return_dict), mimetype="application/json", status=200)
except:
pass
title = wmts.identification.title
if not name:
if title:
name = wmts.identification.title
else:
name = urlsplit(url).netloc
for layer, layer_metadata in wmts.contents.items():
if layer is None or layer_metadata.name is None:
continue
logger.info("Registering layer %s" % layer_metadata.name)
layer_uuid = str(uuid.uuid1())
try:
keywords = map(lambda x: x[:100], layer_metadata.keywords)
except:
keywords = []
if not layer_metadata.abstract:
abstract = ""
else:
abstract = layer_metadata.abstract
bbox = list(layer_metadata.boundingBoxWGS84 or (-179.0, -89.0, 179.0, 89.0))
# Need to check if layer already exists??
saved_layer, created = Layer.objects.get_or_create(
typename=layer_metadata.name,
service=service,
defaults=dict(
name=layer_metadata.name,
store=service.name, # ??
storeType="remoteStore",
workspace="remoteWorkspace",
title=layer_metadata.title or layer_metadata.name,
abstract=layer_metadata.abstract or ("Not provided"),
uuid=layer_uuid,
owner=None,
srid=layer_metadata.tilematrixsets,
bbox_x0=bbox[0],
bbox_x1=bbox[2],
bbox_y0=bbox[1],
bbox_y1=bbox[3],
),
)
if created:
saved_layer.save()
saved_layer.set_default_permissions()
saved_layer.keywords.add(*keywords)
set_attributes(saved_layer)
service_layer, created = ServiceLayer.objects.get_or_create(typename=layer_metadata.name, service=service)
service_layer.layer = saved_layer
service_layer.title = layer_metadata.title
service_layer.description = layer_metadata.abstract
service_layer.styles = layer_metadata.styles
service_layer.save()
message = "%d Layers Registered" % count
return_dict = {"status": "ok", "msg": message}
return HttpResponse(json.dumps(return_dict), mimetype="application/json", status=200)
