def test_metadata_available_after_upload(self):
"""Test metadata is available after upload
"""
# Upload hazard data for this test
name = 'jakarta_flood_design.tif'
exposure_filename = os.path.join(UNITDATA, 'hazard', name)
exposure_layer = save_to_geonode(exposure_filename,
user=self.user,
overwrite=True)
layer_name = exposure_layer.typename
server_url = settings.GEOSERVER_BASE_URL + '/ows'
wcs = WebCoverageService(server_url, version='1.0.0')
layer_appears_immediately = layer_name in wcs.contents
wait_time = 0.5
time.sleep(wait_time)
wcs2 = WebCoverageService(server_url, version='1.0.0')
layer_appears_afterwards = layer_name in wcs2.contents
msg = ('Layer %s was not found after %s seconds in WxS contents '
'on server %s.\n'
'WCS contents: %s\n' %
(layer_name, wait_time, server_url, wcs.contents))
assert layer_appears_afterwards, msg
msg = ('Layer %s was not found in WxS contents on server %s.\n'
'WCS contents: %s\n' % (layer_name, server_url, wcs.contents))
assert layer_appears_immediately, msg
def test_metadata_available_after_upload(self):
"""Test metadata is available after upload
"""
# Upload exposure data for this test
name = 'Population_2010'
exposure_filename = '%s/%s.asc' % (TESTDATA, name)
exposure_layer = save_to_geonode(exposure_filename,
user=self.user, overwrite=True)
layer_name = exposure_layer.typename
server_url = settings.GEOSERVER_BASE_URL + '/ows'
wcs = WebCoverageService(server_url, version='1.0.0')
layer_appears_immediately = layer_name in wcs.contents
wait_time = 0.5
import time
time.sleep(wait_time)
wcs2 = WebCoverageService(server_url, version='1.0.0')
layer_appears_afterwards = layer_name in wcs2.contents
msg = ('Layer %s was not found after %s seconds in WxS contents '
'on server %s.\n'
'WCS contents: %s\n' % (layer_name,
wait_time,
server_url,
wcs.contents))
assert layer_appears_afterwards, msg
msg = ('Layer %s was not found in WxS contents on server %s.\n'
'WCS contents: %s\n' % (layer_name, server_url, wcs.contents))
assert layer_appears_immediately, msg
def __init__(self):
try:
self.wcs_ahn3 = WebCoverageService(
'https://geodata.nationaalgeoregister.nl/ahn3/wcs',
version='1.0.0')
self.wcs_ahn2 = WebCoverageService(
'https://geodata.nationaalgeoregister.nl/ahn2/wcs',
version='1.0.0')
except:
print("AHN WCS host unavailable")
def getGeoTransformImStack(mSet, verbose_query=True, remove=True):
from osgeo import gdal
import os
wcs = WebCoverageService(
'http://saocompute.eurac.edu/sincohmap/rasdaman/ows?', version='2.0.1')
mContents = wcs.contents[mSet]
indxDate = getIndexLabelFromWCScontents('date', mContents)
subset = 'date(' + mContents.grid.origin[indxDate] + ')'
query = 'for c in ( ' + mSet + ' ) return encode (c[' + subset + '], "tiff", "nodata=-999")'
if verbose_query: print(query)
raster_path = wcps_rasdaman(query,
ip='saocompute.eurac.edu/sincohmap',
verbose=verbose_query)
raster = gdal.Open(raster_path)
if remove:
os.remove(raster_path)
if verbose_query: print('Temporary file has been deleted')
return (raster.GetGeoTransform())
def test_wcs1_server(ows_server):
# Use owslib to confirm that we have a somewhat compliant WCS service
wcs = WebCoverageService(url=ows_server.url + "/wcs", version="1.0.0")
# Ensure that we have at least some layers available
contents = list(wcs.contents)
assert contents
def getGeotiffFromWebCoverageService(url, version, bbox, identifier, frmt,
directory, filename):
""" Obtain data from WebCoverageService.
:url: url from which to obtain the data
:version: version of the data to obtain
:bbox: bounding box
:identifier: user-specified filename
:format: data format to obtain
:directory: folder in which file is to be written
:filename: filename of file to write
"""
# create path
direc = "./" + directory + "/"
dirFile = direc + filename + ".tif"
# check if directory and file exist
if not os.path.exists(direc):
os.makedirs(direc)
if not os.path.isfile(dirFile):
wcs = WebCoverageService(url, version=version)
response = wcs.getCoverage(identifier=identifier,
bbox=bbox,
format=frmt,
crs='urn:ogc:def:crs:EPSG::28992',
resx=0.5,
resy=0.5)
with open(dirFile, 'wb') as file:
file.write(response.read())
def __init__(self, config, grid):
"""
Initialization code for this specific provider. First initialize the
base provider and then to some custom setup stuff specific to the
wcs provider.
The provider needs to update the self.available_layers attribute and
append all the layers that it can provide to this attribute. Since
a provider can literally provide any sort of layer and any number of
them, this cannot be done automatically, and therefore must be done
explicitly in the provider's __init__.
"""
provider.Provider.__init__(self, config, grid)
try:
self._layers = {}
for wcs_url in config:
wcs = WebCoverageService(wcs_url, version='1.0.0')
contents = list(wcs.contents)
for layer in contents:
self.available_layers.append(layer)
#make a mapping in the _layers variable about which wcs url
#we need to query to fetch a particular layer
self._layers.update({layer: wcs_url})
except:
logger.debug(
" - %s provider couldn't find any layers to make available.")
def loadWCS(folder, out_name, WCS_URL, Version, layerName, bbox, srid):
folder = folder
urls = WCS_URL
version = Version
bbox = bbox
input_value_raster = layerName
crs_num = 'urn:ogc:def:crs:EPSG::' + str(srid)
if urls == 'None':
return ("Please provide WCS parameters")
wcs = WebCoverageService(urls, version)
#print(list(wcs.contents))
#
# print([op.name for op in wcs.operations])
cvg = wcs.contents[input_value_raster]
if bbox == 'None':
bbox = cvg.boundingBoxWGS84
response = wcs.getCoverage(identifier=input_value_raster,
bbox=bbox,
format='GEOTIFF_FLOAT32',
crs='urn:ogc:def:crs:EPSG::28992',
resx=0.5,
resy=0.5)
temp_raster = folder + '//' + out_name + '.tif'
with open(temp_raster, 'wb') as file:
file.write(response.read())
def getCube(self, maptype, depths, datatypes, bounds, overwrite=False):
#check if all files are already downloaded
fpaths = [
'../tmp/Hadocha_' + maptype + '_' + depth + 'cm_' + datatype +
'.tif' for depth in depths for datatype in datatypes
]
if (min([os.path.isfile(fpath) for fpath in fpaths])
and not overwrite):
print('all files already downloaded for: ' + maptype)
return fpaths
#set up the Web Coverage Service. This sometimes raises errors, so retry
print('setting up WCS for maptype: ' + maptype)
for attempt in range(5):
try:
wcs = WebCoverageService(
'http://maps.isric.org/mapserv?map=/map/' + maptype +
'.map',
version='1.0.0')
except:
print('failed to connect to WCS ' + str(attempt + 1) +
' times to: ' + maptype)
else:
break
else:
print('failed to connect to WCS, try again later')
return []
#start retrieving map data
for depth in depths:
for datatype in datatypes:
fpath = '../tmp/Hadocha_' + maptype + '_' + depth + 'cm_' + datatype + '.tif'
#also handle exceptions for retrieving files
if (not os.path.isfile(fpath) or overwrite):
for attempt in range(5):
try:
response = wcs.getCoverage(
identifier=maptype + '_' + depth + 'cm_' +
datatype,
crs='urn:ogc:def:crs:EPSG::152160',
bbox=(bounds.minx, bounds.miny, bounds.maxx,
bounds.maxy),
resx=20,
resy=20,
format='GEOTIFF_INT16')
except:
print('coverage failed ' + str(attempt + 1) +
' times for: ' + fpath)
else:
with open(fpath, 'wb') as file:
file.write(response.read())
# print('file: '+fpath+'downloaded')
break
else:
print('file not retrieved: ' + fpath)
fpaths.remove(fpath)
# else:
# print('file already downloaded: '+fpath)
# print('map at location: '+fpath)
return fpaths
def wcsRequest(self, layer='AGRICULTURE'):
self.layer = layer
ID = 'your ID'
wcs_url = 'https://services.sentinel-hub.com/ogc/wcs/'+ID
wcs = WebCoverageService(wcs_url, version='1.0.0')
self.x, self.y = self.deg2num(self.lat_center, self.lon_center, self.zoom)
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)
inProj = Proj(init='epsg:4326')
outProj = Proj(init='epsg:3857')
x1,y1 = transform(inProj,outProj,self.lon_min,self.lat_min)
x2,y2 = transform(inProj,outProj,self.lon_max,self.lat_max)
bb=(x1, y1, x2, y2)
self.wcsOut = wcs.getCoverage(identifier=self.layer,
time=None,
width=800,
height=800,
bbox = bb,
format = 'GeoTIFF')
self.imgTiff = Image.open(self.wcsOut)
self.imgArr = np.array(self.imgTiff)
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 __init__(self, config, grid):
"""
Current Issues:
- only 'now' works as starttime in the model. any other model gives an
error at line 132 (req_url).
Somethingsomething dictionary not fed the correct keys.
"""
#
# Initialize the provider. This sets up a temporary directory and some
# general stuff that all providers need.
#
provider.Provider.__init__(self, config, grid)
#
# First figure out which GFS forecast has been most recently uploaded.
#
gfs_layers=[]
self.gfs_wcs_access_urls={}
gfs_dt=[]
start = round_datetime(dt=datetime.datetime.utcnow(), seconds=-21600)
logger.debug("Looking for most recent GFS dataset")
for offset in xrange(-21600*1, -21600*12, -21600):
logger.debug("trying date")
gfs_latest = start + datetime.timedelta(seconds=offset)
gfs_dt.append(gfs_latest)
logger.debug("create date")
wcs_url=gfs_latest.strftime("http://nomads.ncdc.noaa.gov/thredds/wcs/gfs-004/%Y%m/%Y%m%d/gfs_4_%Y%m%d_%H%M_000.grb2")
try:
logger.debug("Trying WCS at %s"%(wcs_url))
wcs = WebCoverageService(wcs_url, version='1.0.0')
logger.debug("Fine...")
except:
logger.debug("Exception! Continue to next loop!!")
continue
logger.debug("moving on...")
logger.debug("Connected to GFS WCS at %s"%(wcs_url))
contents = list(wcs.contents)
if len(contents) > 0:
for layer in contents:
gfs_layers.append(layer)
self.available_layers.append(layer)
for hours in xrange(0,300,3):
timestamp = gfs_latest + datetime.timedelta(hours=hours)
timestamp = timestamp.replace(tzinfo=pytz.utc)
hr = "%.3d"%(hours)
wcs_access_url = gfs_latest.strftime("http://nomads.ncdc.noaa.gov/thredds/wcs/gfs-004/%Y%m/%Y%m%d/gfs_4_%Y%m%d_%H%M_"+hr+".grb2")
cache_key = gfs_latest.strftime("gfsrun-%Y%m%d%H%M-"+hr+"-")
self.gfs_wcs_access_urls.update({timestamp.isoformat():{'url':wcs_access_url,'cache_key':cache_key}})
self.gfs_run_timestamp = gfs_latest
break
else:
continue
logger.debug("The following GFS WCS urls will be used for timesteps:")
for k in sorted(self.gfs_wcs_access_urls):
logger.debug("Timestamp: %s WCS URL: %s"%(k,self.gfs_wcs_access_urls[k]))
def test_wcs1_getcoverage_netcdf(ows_server):
# Use owslib to confirm that we have a somewhat compliant WCS service
wcs = WebCoverageService(url=ows_server.url + "/wcs", version="1.0.0")
# Ensure that we have at least some layers available
contents = list(wcs.contents)
test_layer_name = contents[0]
test_layer = wcs.contents[test_layer_name]
bbox = test_layer.boundingBoxWGS84
output = wcs.getCoverage(identifier=contents[0],
format='netCDF',
bbox=pytest.helpers.enclosed_bbox(bbox),
crs='EPSG:4326',
width=400,
height=300)
assert output
assert output.info()['Content-Type'] == 'application/x-netcdf'
output = wcs.getCoverage(identifier=contents[0],
format='netCDF',
bbox=pytest.helpers.enclosed_bbox(bbox),
crs='I-CANT-BELIEVE-ITS-NOT-EPSG:4326',
width=400,
height=300)
assert output
assert output.info()['Content-Type'] == 'application/x-netcdf'
def test_ows_interfaces_wcs():
service = WebCoverageService(WCS_SERVICE_URL, version='1.0.0')
# Check each service instance conforms to OWSLib interface
service.alias = 'WCS'
isinstance(service, owslib.coverage.wcs100.WebCoverageService_1_0_0)
# URL attribute
assert service.url == WCS_SERVICE_URL
# version attribute
assert service.version == '1.0.0'
# Identification object
assert hasattr(service, 'identification')
# Check all ServiceIdentification attributes
assert service.identification.type == 'OGC:WCS'
for attribute in [
'type', 'version', 'title', 'abstract', 'keywords', 'fees'
]:
assert hasattr(service.identification, attribute)
# Check all ServiceProvider attributes
for attribute in ['name', 'url', 'contact']:
assert hasattr(service.provider, attribute)
# Check all operations implement IOperationMetadata
for op in service.operations:
for attribute in ['name', 'methods']:
assert hasattr(op, attribute)
# Check all contents implement IContentMetadata as a dictionary
isinstance(service.contents, dict)
# Check any item (WCS coverage, WMS layer etc) from the contents of each service
# Check it conforms to IContentMetadata interface
# get random item from contents dictionary -has to be a nicer way to do this!
content = service.contents[list(service.contents.keys())[0]]
for attribute in [
'id', 'title', 'boundingBox', 'boundingBoxWGS84', 'crsOptions',
'styles', 'timepositions'
]:
assert hasattr(content, attribute)
def __init__(self, config, grid):
self.name = "example"
self._config = config
self._layers = {}
print "Initializing wxs provider:"
print grid
print config
##
#
# todo: move all this grid/caching stuff to the base class? providers
# shouldnt have to worry about this, and really not about reprojecting
# to a equidistant projction either. all that a provider needs to do
# is provide data for a layer name
#
self._grid = grid
self._cache = os.path.join(
os.environ.get('GEM_WORKING_DIR', '/tmp/gem'), "wcs_cache",
self._grid['uuid'])
if not os.path.isdir(self._cache):
os.makedirs(self._cache) #create the cache directory
for wcs_url in config:
print "* init url="
print wcs_url
wcs = WebCoverageService(wcs_url, version='1.0.0')
contents = list(wcs.contents)
for layer in contents:
#make a mapping in the _layers variable about which wcs url
#we need to query to fetch a particular layer
self._layers.update({layer: wcs_url})
def init_config(self, config_file):
_wcs = WebCoverageService(self.url, version="2.0.1")
config = {}
_covs = _wcs.contents.keys()
config['coverages'] = {}
for _cov in _covs:
#print "writting coverage info for "+_cov
#if _cov not in self.banned:
try:
t_cov = {}
try:
t_cov['time_axis_name'] = [
item for item in _wcs.contents[_cov].grid.axislabels
if item not in self.axis_removes
][0]
except Exception, e:
t_cov['time_axis_name'] = ''
spatial_axis = [
item for item in _wcs.contents[_cov].grid.axislabels
if item in self.axis_removes
]
del _wcs.contents[_cov]
for p in spatial_axis:
t_cov[get_lat_long(p) + '_axis_name'] = p
# gather X and Y coords definition
t_cov['name'] = _cov
config['coverages'][_cov] = t_cov
self.coverages[_cov] = t_cov
except Exception, e:
print e
print "coverage {} failed you should check it".format(_cov)
def getReferenceImage(mSet,
verbose_query=True,
rotate=False,
x0=0,
xN=0,
y0=0,
yN=0):
if x0 != 0 and xN != 0 and y0 != 0 and yN != 0:
DO_CROP = 1
else:
DO_CROP = 0
print(DO_CROP)
# Select WCS server and service version
wcs = WebCoverageService(
'http://saocompute.eurac.edu/sincohmap/rasdaman/ows?', version='2.0.1')
mContents = wcs.contents[mSet]
indxMaster = getIndexLabelFromWCScontents('master_date', mContents)
indxSlave = getIndexLabelFromWCScontents('slave_date', mContents)
indxN = getIndexLabelFromWCScontents('N', mContents)
indxE = getIndexLabelFromWCScontents('E', mContents)
masterDates = getMasterTimeAxis(mSet, mContents, indxSlave, indxN, indxE)
slaveDates = getSlaveTimeAxis(mSet, mContents, indxMaster, indxN, indxE)
date0M = masterDates[0].strftime('%Y-%m-%d')
date0S = slaveDates[0].strftime('%Y-%m-%d')
print(date0M)
print(date0S)
#subset = 'master_date(\"' + date0M +'\"), slave_date(\"' + date0S +'\")'
if DO_CROP:
subset = 'E(' + str(x0) + ':' + str(xN) + '), N(' + str(y0) + ':' + str(yN) + \
'), master_date(\"' + date0M +'\"), slave_date(\"' + date0S +'\")'
else:
subset = 'master_date(\"' + date0M + '\"), slave_date(\"' + date0S + '\")'
query = 'for c in ( ' + mSet + ' ) return encode (c[' + subset + '], "tiff")'
subset_coherence = wcps_rasdaman(query,
ip='saocompute.eurac.edu/sincohmap',
verbose=verbose_query)
if rotate:
refPath = mSet + '_reference_image_rotated.tiff'
print(subset_coherence)
print(refPath)
rotate_tiff_file(subset_coherence, refPath)
os.remove(subset_coherence)
else:
refPath = mSet + '_reference_image.tiff'
shutil.move(subset_coherence, refPath)
return (refPath)
def get_raster_wcs(
coordinates: Union[Iterable, Sequence[Union[float, str]]],
geographic: bool = True,
layer: str = None,
geoserver: str = GEO_URL,
) -> bytes:
"""Return a subset of a raster image from the local GeoServer via WCS 2.0.1 protocol.
For geographic rasters, subsetting is based on WGS84 (Long, Lat) boundaries. If not geographic, subsetting based
on projected coordinate system (Easting, Northing) boundaries.
Parameters
----------
coordinates : Sequence[Union[int, float, str]]
Geographic coordinates of the bounding box (left, down, right, up)
geographic : bool
If True, uses "Long" and "Lat" in WCS call. Otherwise uses "E" and "N".
layer : str
Layer name of raster exposed on GeoServer instance, e.g. 'public:CEC_NALCMS_LandUse_2010'
geoserver: str
The address of the geoserver housing the layer to be queried. Default: http://pavics.ouranos.ca/geoserver/.
Returns
-------
bytes
A GeoTIFF array.
"""
(left, down, right, up) = coordinates
if geographic:
x, y = "Long", "Lat"
else:
x, y = "E", "N"
wcs = WebCoverageService(url=urljoin(geoserver, "ows"), version="2.0.1")
try:
resp = wcs.getCoverage(
identifier=[layer],
format="image/tiff",
subsets=[(x, left, right), (y, down, up)],
timeout=120,
)
except Exception as e:
raise Exception(e)
data = resp.read()
try:
etree.fromstring(data)
# The response is an XML file describing the server error.
raise ChildProcessError(data)
except etree.XMLSyntaxError:
# The response is the DEM array.
return data
def run_test_resource(resource_type, url):
"""tests a CSW service and provides run metrics"""
if resource_type not in RESOURCE_TYPES.keys():
msg = gettext('Invalid resource type')
msg2 = '%s: %s' % (msg, resource_type)
LOGGER.error(msg2)
raise RuntimeError(msg2)
title = None
start_time = datetime.datetime.utcnow()
message = None
try:
if resource_type == 'OGC:WMS':
ows = WebMapService(url)
elif resource_type == 'OGC:WFS':
ows = WebFeatureService(url)
elif resource_type == 'OGC:WCS':
ows = WebCoverageService(url)
elif resource_type == 'OGC:WPS':
ows = WebProcessingService(url)
elif resource_type == 'OGC:CSW':
ows = CatalogueServiceWeb(url)
elif resource_type == 'OGC:SOS':
ows = SensorObservationService(url)
elif resource_type in ['WWW:LINK', 'urn:geoss:waf']:
ows = urlopen(url)
if resource_type == 'WWW:LINK':
import re
try:
title_re = re.compile("<title>(.+?)</title>")
title = title_re.search(ows.read()).group(1)
except:
title = url
elif resource_type == 'urn:geoss:waf':
title = 'WAF %s %s' % (gettext('for'), urlparse(url).hostname)
elif resource_type == 'FTP':
ows = urlopen(url)
title = urlparse(url).hostname
success = True
if resource_type.startswith('OGC:'):
title = ows.identification.title
if title is None:
title = '%s %s %s' % (resource_type, gettext('for'), url)
except Exception as err:
msg = str(err)
LOGGER.exception(msg)
message = msg
success = False
end_time = datetime.datetime.utcnow()
delta = end_time - start_time
response_time = '%s.%s' % (delta.seconds, delta.microseconds)
return [title, success, response_time, message, start_time]
def ws_init(access_type, endpoint):
'''Initialise a Web Service object'''
if access_type == 'wfs':
ws = WebFeatureService(endpoint)
elif access_type == 'wms:
ws = WebMapService(endpoint)
else:
ws = WebCoverageService(endpoint)
return ws
def get_metadata(server_url, layer_name=None):
"""Uses OWSLib to get the metadata for a given layer
Input
server_url: e.g. http://localhost:8001/geoserver-geonode-dev/ows
layer_name: Name of layer - must follow the convention workspace:name
If None metadata for all layers will be returned as a
dictionary with one entry per layer
Output
metadata: Dictionary of metadata fields for specified layer or,
if layer_name is None, a dictionary of metadata dictionaries
"""
# Get all metadata from server
wcs = WebCoverageService(server_url, version='1.0.0')
wfs = WebFeatureService(server_url, version='1.0.0')
# Take care of input options
if layer_name is None:
layer_names = wcs.contents.keys() + wfs.contents.keys()
else:
layer_names = [layer_name]
#FIXME(Ariel): This is a weak way of finding the geoserver_url
geoserver_url = server_url[:-4]
# Get metadata for requested layer(s)
metadata = {}
for name in layer_names:
if name in wcs.contents:
layer = wcs.contents[name]
layer.datatype = 'raster' # Monkey patch layer type
elif name in wfs.contents:
layer = wfs.contents[name]
layer.datatype = 'vector' # Monkey patch layer type
else:
msg = ('Layer %s was not found in WxS contents on server %s.\n'
'WCS contents: %s\n'
'WFS contents: %s\n' % (name, server_url,
wcs.contents, wfs.contents))
raise Exception(msg)
layer_metadata = get_metadata_from_layer(layer)
tile_url = "%s/gwc/service/gmaps?layers=%s&zoom={z}&x={x}&y={y}&format=image/png" % (geoserver_url, name)
layer_metadata['server_url'] = server_url
layer_metadata['tile_url'] = tile_url
metadata[name] = layer_metadata
# Return metadata for one or all layers
if layer_name is not None:
return metadata[layer_name]
else:
return metadata
def __init__(self, url, dates, variable, bbox, single=False):
super(WCSHelper, self).__init__()
self.url = url
self.single = single
self.dates = dates
self.variable = variable
self.bbox = bbox
self.owslib_log = logging.getLogger('owslib')
self.owslib_log.setLevel(logging.DEBUG)
self.wcs = WebCoverageService(url, version="1.0.0")
def wcs_links(wcs_url,
identifier,
bbox=None,
crs=None,
height=None,
width=None,
exclude_formats=True,
quiet=True,
version='1.0.0'):
# FIXME(Ariel): This would only work for layers marked for public view,
# what about the ones with permissions enabled?
try:
wcs = WebCoverageService(wcs_url, version=version)
except ServiceException as err:
err_msg = 'WCS server returned exception: %s' % err
if not quiet:
logger.warn(err_msg)
raise GeoNodeException(err_msg)
msg = ('Could not create WCS links for layer "%s",'
' it was not in the WCS catalog,'
' the available layers were: "%s"' %
(identifier, wcs.contents.keys()))
output = []
formats = []
if identifier not in wcs.contents:
if not quiet:
raise RuntimeError(msg)
else:
logger.warn(msg)
else:
coverage = wcs.contents[identifier]
formats = coverage.supportedFormats
for f in formats:
if exclude_formats and f in DEFAULT_EXCLUDE_FORMATS:
continue
# roundabout, hacky way to accomplish getting a getCoverage url.
# nonetheless, it's better than having to load an entire large
# coverage just to generate a URL
fakeUrl = wcs.getCoverage(identifier=coverage.id,
format=f,
bbox=bbox,
crs=crs,
height=20,
width=20).geturl()
url = sub(r'(height=)20(\&width=)20', r'\g<1>{0}\g<2>{1}',
fakeUrl).format(height, width)
# The outputs are: (ext, name, mime, url)
# FIXME(Ariel): Find a way to get proper ext, name and mime
# using format as a default for all is not good enough
output.append((f, f, f, url))
return output
def getDatesImStack(mSet):
wcs = WebCoverageService(
'http://saocompute.eurac.edu/sincohmap/rasdaman/ows?', version='2.0.1')
mContents = wcs.contents[mSet]
indxN = getIndexLabelFromWCScontents('N', mContents)
indxE = getIndexLabelFromWCScontents('E', mContents)
dates = getTimeAxis(mSet, mContents, indxN, indxE, verbose_query=False)
return (dates)
def get_raster_wcs(coordinates, geographic=True, layer=None):
"""Return a subset of a raster image from the local GeoServer via WCS 2.0.1 protocol.
For geoggraphic rasters, subsetting is based on WGS84 (Long, Lat) boundaries. If not geographic, subsetting based
on projected coordinate system (Easting, Northing) boundries.
Parameters
----------
coordinates : sequence
Geographic coordinates of the bounding box (left, down, right, up)
geographic : bool
If True, uses "Long" and "Lat" in WCS call. Otherwise uses "E" and "N".
layer : str
Layer name of raster exposed on GeoServer instance. E.g. 'public:CEC_NALCMS_LandUse_2010'
Returns
-------
bytes
A GeoTIFF array.
"""
from owslib.wcs import WebCoverageService
from lxml import etree
(left, down, right, up) = coordinates
if geographic:
x, y = 'Long', 'Lat'
else:
x, y = 'E', 'N'
wcs = WebCoverageService('http://boreas.ouranos.ca/geoserver/ows',
version='2.0.1')
try:
resp = wcs.getCoverage(identifier=[
layer,
],
format='image/tiff',
subsets=[(x, left, right), (y, down, up)])
except Exception as e:
raise Exception(e)
data = resp.read()
try:
etree.fromstring(data)
# The response is an XML file describing the server error.
raise ChildProcessError(data)
except etree.XMLSyntaxError:
# The response is the DEM array.
return data
def __init__(self, host, **kwargs):
"""Create a WCS client attached to the given host address (an URL).
Args:
host (str): the server URL.
**kwargs: The keyword arguments with credentials to access OGC WCS.
"""
invalid_parameters = set(kwargs) - {"username", "password"}
if invalid_parameters:
raise AttributeError(
'invalid parameter(s): {}'.format(invalid_parameters))
if 'username' in kwargs:
auth = Authentication(username=kwargs['username'],
password=kwargs['password'])
self.wcs_owslib = WebCoverageService(host,
version='1.0.0',
auth=auth)
else:
self.wcs_owslib = WebCoverageService(host, version='1.0.0')
def test_wcs1_describecoverage(ows_server):
# Use owslib to confirm that we have a somewhat compliant WCS service
wcs = WebCoverageService(url=ows_server.url + "/wcs", version="1.0.0")
# Ensure that we have at least some layers available
contents = list(wcs.contents)
test_layer_name = contents[0]
resp = wcs.getDescribeCoverage(test_layer_name)
gc_xds = get_xsd("1.0.0/describeCoverage.xsd")
assert gc_xds.validate(resp)
def get_layers(ahn_version='ahn3'):
'''
Returns a list of layers which can be used in function "to_tif"
Parameters
----------
ahn_version: str,
specify 'ahn2' or 'ahn3'
'''
url = 'https://geodata.nationaalgeoregister.nl/{}/wcs?'.format(ahn_version)
wcs = WebCoverageService(url,version='1.0.0')
return list(wcs.contents.keys())
def datasets():
"""
Shows information on datasets
"""
wcss = []
for descr, url in current_app.config.get('WCS', {}).items():
layers = []
wcs = WebCoverageService(url, version='1.0.0')
for lyr in list(wcs.contents):
layers.append({'name': lyr, 'data': wcs.contents[lyr]})
print dir(wcs.contents[lyr])
wcss.append({'url': url, 'layers': layers})
return render_template("admin/datasets.html", wcs=wcss)
def _get_service_and_coverage_list(service_id):
if service_id not in SoilGrids.MAP_SERVICES.keys():
raise ValueError(
'Please provide a service id from the following options: \n{}'.
format('\n'.join([
'{}: {}'.format(key, value['name'])
for key, value in SoilGrids.MAP_SERVICES.items()
])))
else:
service_link = SoilGrids.MAP_SERVICES[service_id]['link']
wcs = WebCoverageService(service_link, version='1.0.0')
coverage_list = list(wcs.contents)
return wcs, coverage_list
def get_dtm(path_out, minlong,maxlong,minlat,maxlat):
bbox=(minlong,minlat,maxlong,maxlat)
url="http://services.ga.gov.au/gis/services/DEM_SRTM_1Second_over_Bathymetry_Topography/MapServer/WCSServer?"
wcs = WebCoverageService(url,version='1.0.0')
cvg=wcs.getCoverage(identifier='1', bbox=bbox, format='GeoTIFF', crs=4326, width=200, height=200)
f = open(path_out, 'wb')
bytes_written = f.write(cvg.read())
f.close()
print("dtm geotif saved as",path_out)
