def render(self, params):
map_ = self.create_map()
use_name = (params.version == Version(1, 0))
for coverage in params.coverages:
# ReferenceableDatasets are not supported in WCS < 2.0
if issubclass(coverage.real_type, models.ReferenceableDataset):
raise NoSuchCoverageException((coverage.identifier,))
data_items = self.data_items_for_coverage(coverage)
native_format = self.get_native_format(coverage, data_items)
layer = self.layer_for_coverage(
coverage, native_format, params.version
)
map_.insertLayer(layer)
for outputformat in self.get_all_outputformats(not use_name):
map_.appendOutputFormat(outputformat)
request = ms.create_request(params)
raw_result = ms.dispatch(map_, request)
result = result_set_from_raw_data(raw_result)
return result
def render(self):
mapfile_path = get_eoxserver_config().get("wmm", "mapfile")
map_ = ms.mapObj(mapfile_path) #TODO: path to map
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
decoder = CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join(
map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms)
)
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
ms_request = ms.create_request((
("service", "WMS"),
("version", "1.3.0"),
("request", "GetCapabilities"),
))
raw_result = map_.dispatch(ms_request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def test_result_set_from_raw(self):
result_set = result_set_from_raw_data(self.example_multipart)
self.assertTrue(len(result_set) == 2)
first = result_set[0]
second = result_set[1]
if isinstance(first.data, str):
first_data = b(first.data)
else:
first_data = first.data
if isinstance(second.data, str):
second_data = b(second.data)
else:
second_data = second.data
self.assertEqual(first_data, b"This is the body of the message.")
self.assertEqual(first.content_type, b"text/plain")
self.assertEqual(first.filename, b"message.msg")
self.assertEqual(first.identifier, b"message-part")
self.assertEqual(
second_data,
b"PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUgYm9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg=="
)
def render(self, layer_groups, request_values, request, **options):
config = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(request)
map_ = ms.Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": http_service_url,
}, namespace="ows")
map_.setMetaData("wms_getfeatureinfo_formatlist", "text/html")
map_.setProjection("EPSG:4326")
session = self.setup_map(layer_groups, map_, options)
# check if the required format is EO O&M
frmt = pop_param(request_values, "info_format")
use_eoom = False
if frmt in ("application/xml", "text/xml"):
request_values.append(("info_format", "application/vnd.ogc.gml"))
use_eoom = True
else:
request_values.append(("info_format", frmt))
with session:
request = ms.create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
if not use_eoom:
# just return the response
return result, get_content_type(result)
else:
# do a postprocessing step and get all identifiers in order
# to encode them with EO O&M
decoder = GMLFeatureDecoder(result[0].data_file.read())
identifiers = decoder.identifiers
coverages = models.Coverage.objects.filter(
identifier__in=identifiers
)
# sort the result with the returned order of coverages
lookup_table = dict((c.identifier, c) for c in coverages)
coverages = [
lookup_table[identifier] for identifier in identifiers
]
# encode the coverages with the EO O&M
encoder = WCS20EOXMLEncoder()
return [
ResultBuffer(
encoder.serialize(
encoder.encode_coverage_descriptions(coverages)
), encoder.content_type
)
], encoder.content_type
def render(self, layer_groups, request_values, **options):
config = CapabilitiesConfigReader(get_eoxserver_config())
map_ = ms.Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": config.http_service_url,
}, namespace="ows")
map_.setMetaData("wms_getfeatureinfo_formatlist", "text/html")
map_.setProjection("EPSG:4326")
session = self.setup_map(layer_groups, map_, options)
# check if the required format is EO O&M
frmt = pop_param(request_values, "info_format")
use_eoom = False
if frmt in ("application/xml", "text/xml"):
request_values.append(("info_format", "application/vnd.ogc.gml"))
use_eoom = True
else:
request_values.append(("info_format", frmt))
with session:
request = ms.create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
if not use_eoom:
# just return the response
return result, get_content_type(result)
else:
# do a postprocessing step and get all identifiers in order
# to encode them with EO O&M
decoder = GMLFeatureDecoder(result[0].data_file.read())
identifiers = decoder.identifiers
coverages = models.Coverage.objects.filter(
identifier__in=identifiers
)
# sort the result with the returned order of coverages
lookup_table = dict((c.identifier, c) for c in coverages)
coverages = [
lookup_table[identifier] for identifier in identifiers
]
# encode the coverages with the EO O&M
encoder = WCS20EOXMLEncoder()
return [
ResultBuffer(
encoder.serialize(
encoder.encode_coverage_descriptions(coverages)
), encoder.content_type
)
], encoder.content_type
def test_result_set_from_raw(self):
result_set = result_set_from_raw_data(self.example_multipart)
self.assertTrue(len(result_set) == 2)
first = result_set[0]
second = result_set[1]
self.assertEqual(str(first.data), "This is the body of the message.")
self.assertEqual(first.content_type, "text/plain")
self.assertEqual(first.filename, "message.msg")
self.assertEqual(first.identifier, "message-part")
self.assertEqual(str(second.data), "PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUgYm9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==")
def render(self, layer_groups, request_values, **options):
map_ = ms.Map()
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
session = self.setup_map(layer_groups, map_, options)
with session:
request = ms.create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, layer_groups, request_values, **options):
map_ = ms.Map()
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
crss = CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join("EPSG:%d"%v for v in crss.supported_crss_wms)
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
self.check_parameters(map_, request_values)
with self.setup_map(layer_groups, map_, options) as session:
request = ms.create_request(self._alter_request(request_values))
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, params):
map_ = self.create_map()
use_name = (params.version == Version(1, 0))
for coverage in params.coverages:
# ReferenceableDatasets are not supported in WCS < 2.0
if coverage.grid.is_referenceable:
raise NoSuchCoverageException((coverage.identifier,))
data_locations = self.arraydata_locations_for_coverage(coverage)
native_format = self.get_native_format(coverage, data_locations)
layer = self.layer_for_coverage(
coverage, native_format, params.version
)
map_.insertLayer(layer)
for outputformat in self.get_all_outputformats(not use_name):
map_.appendOutputFormat(outputformat)
request = ms.create_request(params)
raw_result = ms.dispatch(map_, request)
result = result_set_from_raw_data(raw_result)
# load XML using lxml
# find and exclude <metadataLink> nodes if present
# re-encode
xml_result = etree.fromstring(result[0].data)
for elem in xml_result.xpath('//*[local-name() = "metadataLink"]'):
elem.getparent().remove(elem)
xml_result_data = etree.tostring(xml_result, pretty_print=True, encoding='UTF-8', xml_declaration=True)
result[0] = ResultBuffer(xml_result_data, result[0].content_type)
return result
def render(self, params):
map_ = self.create_map()
use_name = (params.version == Version(1, 0))
for coverage in params.coverages:
# ReferenceableDatasets are not supported in WCS < 2.0
if issubclass(coverage.real_type, models.ReferenceableDataset):
raise NoSuchCoverageException((coverage.identifier, ))
data_items = self.data_items_for_coverage(coverage)
native_format = self.get_native_format(coverage, data_items)
layer = self.layer_for_coverage(coverage, native_format,
params.version)
map_.insertLayer(layer)
for outputformat in self.get_all_outputformats(not use_name):
map_.appendOutputFormat(outputformat)
request = ms.create_request(params)
raw_result = ms.dispatch(map_, request)
result = result_set_from_raw_data(raw_result)
return result
def render(self):
mapfile_path = get_eoxserver_config().get("wmm", "mapfile")
map_ = ms.mapObj(mapfile_path) #TODO: path to map
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
decoder = CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join(
map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms))
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
ms_request = ms.create_request((
("service", "WMS"),
("version", "1.3.0"),
("request", "GetCapabilities"),
))
raw_result = map_.dispatch(ms_request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, layer_groups, request_values, **options):
map_ = ms.Map()
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
decoder = CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join(
map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms)
)
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
self.check_parameters(map_, request_values)
session = self.setup_map(layer_groups, map_, options)
with session:
request = ms.create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, collections, coverages, request_values):
conf = CapabilitiesConfigReader(get_eoxserver_config())
suffixes = self.suffixes
map_ = Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": conf.http_service_url,
"service_onlineresource": conf.onlineresource,
"updateSequence": conf.update_sequence,
"name": conf.name,
"title": conf.title,
"abstract": conf.abstract,
"accessconstraints": conf.access_constraints,
"addresstype": "postal",
"address": conf.delivery_point,
"stateorprovince": conf.administrative_area,
"city": conf.city,
"postcode": conf.postal_code,
"country": conf.country,
"contactelectronicmailaddress": conf.electronic_mail_address,
"contactfacsimiletelephone": conf.phone_facsimile,
"contactvoicetelephone": conf.phone_voice,
"contactperson": conf.individual_name,
"contactorganization": conf.provider_name,
"contactposition": conf.position_name,
"fees": conf.fees,
"keywordlist": ",".join(conf.keywords),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="ows")
map_.setProjection("EPSG:4326")
map_.setMetaData({
"getmap_formatlist": ",".join([f.mimeType for f in self.get_wms_formats()]),
"getfeatureinfo_formatlist": "text/html,application/vnd.ogc.gml,text/plain",
}, namespace="wms")
map_extent = None
for collection in collections:
group_name = None
# calculate extent and timextent for every collection
extent = collection.extent_wgs84
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
eo_objects = collection.eo_objects.filter(
begin_time__isnull=False, end_time__isnull=False
)
timeextent = ",".join(
map(
lambda o: (
"/".join(
map(isoformat, o.time_extent)
) + "/PT1S"
), eo_objects
)
)
if len(suffixes) > 1:
# create group layer, if there is more than one suffix for this
# collection
group_name = collection.identifier + "_group"
group_layer = Layer(group_name)
group_layer.setMetaData({
"title": group_name,
"abstract": group_name,
"extent": " ".join(map(str, extent)),
}, namespace="wms")
group_layer.setExtent(*extent)
# add default style
default_class = Class("default")
default_style= Style("default")
default_class.insertStyle(default_style)
group_layer.insertClass(default_class)
map_.insertLayer(group_layer)
for suffix in suffixes:
layer_name = collection.identifier + (suffix or "")
layer = Layer(layer_name)
if group_name:
layer.setMetaData({
"layer_group": "/" + group_name
}, namespace="wms")
layer.setMetaData({
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
"timeextent": timeextent,
}, namespace="wms")
map_.insertLayer(layer)
for coverage in coverages:
extent = coverage.extent_wgs84
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
layer_name = coverage.identifier
layer = Layer(layer_name)
layer.setMetaData({
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
}, namespace="wms")
layer.setExtent(*extent)
map_.insertLayer(layer)
# set the map_extent to a reasonable default value
# in case there is no coverage or collection
if map_extent is None:
map_extent = (0.0, 0.0, 1.0, 1.0)
map_.setExtent(*map_extent)
request = create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, layers, bbox, crs, size, frmt, time, elevation, styles):
if not time:
raise RenderException("Missing mandatory 'time' parameter.")
try:
time = time.value
except AttributeError:
raise RenderException(
"Parameter 'time' must be a slice and not a range.")
llbbox = self.get_llbbox(bbox, crs)
mapfile_path = get_eoxserver_config().get("wmm", "mapfile")
map_ = ms.mapObj(mapfile_path) #TODO: path to map
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
decoder = crss.CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join(
map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms))
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
datasources = []
datasets = []
for layer_name in layers:
layer = map_.getLayerByName(layer_name)
if not layer:
continue
product = layer.metadata.get("wmm_product")
filename = self.generate_filename("tif")
ds = self.create_dataset(llbbox, time, elevation, size, product,
filename)
datasets.append(ds)
if layer.type == ms.MS_LAYER_LINE:
flavor = layer.metadata.get("wmm_flavor")
contour_steps = self.get_contour_intervals(
flavor, llbbox, size)
filename = self.generate_filename("shp")
self.generate_contours(ds, contour_steps, filename)
layer.connectiontype = ms.MS_OGR
layer.connection = filename
layer.data, _ = splitext(basename(filename))
datasources.append(filename)
ms_request = ms.create_request(
(("service", "WMS"), ("version", "1.3.0"), ("request", "GetMap"),
("layers", ",".join(layers)),
("bbox", "%f,%f,%f,%f" % (bbox[1], bbox[0], bbox[3], bbox[2])),
("crs", crs), ("width", str(size[0])), ("height", str(size[1])),
("styles", ",".join(styles)), ("format", frmt)))
raw_result = ms.dispatch(map_, ms_request)
result = result_set_from_raw_data(raw_result)
shp_drv = ogr.GetDriverByName("ESRI Shapefile")
# cleanup datasources and datasets
for filename in datasources:
shp_drv.DeleteDataSource(filename)
for ds in datasets:
driver = ds.GetDriver()
for filename in ds.GetFileList():
os.remove(filename)
return result, get_content_type(result)
def render(self, collections, coverages, request_values, request):
conf = CapabilitiesConfigReader(get_eoxserver_config())
suffixes = self.suffixes
http_service_url = get_http_service_url(request)
map_ = Map()
map_.setMetaData(
{
"enable_request":
"*",
"onlineresource":
http_service_url,
"service_onlineresource":
conf.onlineresource,
"updateSequence":
conf.update_sequence,
"name":
conf.name,
"title":
conf.title,
"abstract":
conf.abstract,
"accessconstraints":
conf.access_constraints,
"addresstype":
"postal",
"address":
conf.delivery_point,
"stateorprovince":
conf.administrative_area,
"city":
conf.city,
"postcode":
conf.postal_code,
"country":
conf.country,
"contactelectronicmailaddress":
conf.electronic_mail_address,
"contactfacsimiletelephone":
conf.phone_facsimile,
"contactvoicetelephone":
conf.phone_voice,
"contactperson":
conf.individual_name,
"contactorganization":
conf.provider_name,
"contactposition":
conf.position_name,
"fees":
conf.fees,
"keywordlist":
",".join(conf.keywords),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="ows")
map_.setProjection("EPSG:4326")
map_.setMetaData(
{
"getmap_formatlist":
",".join([f.mimeType for f in self.get_wms_formats()]),
"getfeatureinfo_formatlist":
"text/html,application/vnd.ogc.gml,text/plain",
},
namespace="wms")
map_extent = None
for collection in collections:
group_name = None
# calculate extent and timextent for every collection
extent = collection.extent_wgs84
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
eo_objects = collection.eo_objects.filter(begin_time__isnull=False,
end_time__isnull=False)
timeextent = ",".join(
map(
lambda o:
("/".join(map(isoformat, o.time_extent)) + "/PT1S"),
eo_objects))
if len(suffixes) > 1:
# create group layer, if there is more than one suffix for this
# collection
group_name = collection.identifier + "_group"
group_layer = Layer(group_name)
group_layer.setMetaData(
{
"title": group_name,
"abstract": group_name,
"extent": " ".join(map(str, extent)),
},
namespace="wms")
minx, miny, maxx, maxy = extent
group_layer.setExtent(minx, miny, maxx, maxy)
# add default style
default_class = Class("default")
default_style = Style("default")
default_class.insertStyle(default_style)
group_layer.insertClass(default_class)
map_.insertLayer(group_layer)
for suffix in suffixes:
layer_name = collection.identifier + (suffix or "")
layer = Layer(layer_name)
if group_name:
layer.setMetaData({"layer_group": "/" + group_name},
namespace="wms")
layer.setMetaData(
{
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
"timeextent": timeextent,
},
namespace="wms")
map_.insertLayer(layer)
for coverage in coverages:
extent = coverage.extent_wgs84
minx, miny, maxx, maxy = extent
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
layer_name = coverage.identifier
layer = Layer(layer_name)
layer.setMetaData(
{
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
},
namespace="wms")
minx, miny, maxx, maxy = extent
layer.setExtent(minx, miny, maxx, maxy)
map_.insertLayer(layer)
# set the map_extent to a reasonable default value
# in case there is no coverage or collection
if map_extent is None:
map_extent = (0.0, 0.0, 1.0, 1.0)
map_minx, map_miny, map_maxx, map_maxy = map_extent
map_.setExtent(map_minx, map_miny, map_maxx, map_maxy)
request = create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)
def render(self, params):
# get coverage related stuff
coverage = params.coverage
# ReferenceableDataset are not supported in WCS < 2.0
if issubclass(coverage.real_type, models.ReferenceableDataset):
raise NoSuchCoverageException((coverage.identifier,))
data_items = self.data_items_for_coverage(coverage)
range_type = coverage.range_type
bands = list(range_type)
subsets = params.subsets
if subsets:
srid = subsets.srid
if srid is not None:
if not crss.validateEPSGCode(srid):
raise RenderException(
"Failed to extract an EPSG code from the CRS URI "
"'%s'." % srid, "subset"
)
# create and configure map object
map_ = self.create_map()
# configure outputformat
native_format = self.get_native_format(coverage, data_items)
if get_format_by_mime(native_format) is None:
native_format = "image/tiff"
frmt = params.format or native_format
if frmt is None:
raise RenderException("Format could not be determined", "format")
mime_type, frmt = split_format(frmt)
imagemode = ms.gdalconst_to_imagemode(bands[0].data_type)
time_stamp = datetime.now().strftime("%Y%m%d%H%M%S")
basename = "%s_%s" % (coverage.identifier, time_stamp)
of = create_outputformat(
mime_type, frmt, imagemode, basename,
getattr(params, "encoding_params", {})
)
map_.appendOutputFormat(of)
map_.setOutputFormat(of)
# TODO: use layer factory here
layer = self.layer_for_coverage(coverage, native_format, params.version)
map_.insertLayer(layer)
for connector in self.connectors:
if connector.supports(data_items):
break
else:
raise OperationNotSupportedException(
"Could not find applicable layer connector.", "coverage"
)
try:
connector.connect(coverage, data_items, layer)
# create request object and dispatch it against the map
request = ms.create_request(
self.translate_params(params, range_type)
)
request.setParameter("format", mime_type)
raw_result = ms.dispatch(map_, request)
finally:
# perform any required layer related cleanup
connector.disconnect(coverage, data_items, layer)
result_set = result_set_from_raw_data(raw_result)
if params.version == Version(2, 0):
if getattr(params, "mediatype", None) in ("multipart/mixed", "multipart/related"):
encoder = WCS20EOXMLEncoder()
is_mosaic = issubclass(
coverage.real_type, models.RectifiedStitchedMosaic
)
if not is_mosaic:
tree = encoder.alter_rectified_dataset(
coverage, getattr(params, "http_request", None),
etree.parse(result_set[0].data_file).getroot(),
subsets.bounding_polygon(coverage) if subsets else None
)
else:
tree = encoder.alter_rectified_stitched_mosaic(
coverage.cast(), getattr(params, "http_request", None),
etree.parse(result_set[0].data_file).getroot(),
subsets.bounding_polygon(coverage) if subsets else None
)
result_set[0] = ResultBuffer(
encoder.serialize(tree),
encoder.content_type
)
# "default" response
return result_set
def render(self, layers, bbox, crs, size, frmt, time, elevation, styles):
if not time:
raise RenderException("Missing mandatory 'time' parameter.")
try:
time = time.value
except AttributeError:
raise RenderException(
"Parameter 'time' must be a slice and not a range."
)
llbbox = self.get_llbbox(bbox, crs)
mapfile_path = get_eoxserver_config().get("wmm", "mapfile")
map_ = ms.mapObj(mapfile_path) #TODO: path to map
map_.setMetaData("ows_enable_request", "*")
map_.setProjection("EPSG:4326")
map_.imagecolor.setRGB(0, 0, 0)
# set supported CRSs
decoder = crss.CRSsConfigReader(get_eoxserver_config())
crss_string = " ".join(
map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms)
)
map_.setMetaData("ows_srs", crss_string)
map_.setMetaData("wms_srs", crss_string)
datasources = []
datasets = []
for layer_name in layers:
layer = map_.getLayerByName(layer_name)
if not layer:
continue
product = layer.metadata.get("wmm_product")
filename = self.generate_filename("tif")
ds = self.create_dataset(
llbbox, time, elevation, size, product, filename
)
datasets.append(ds)
if layer.type == ms.MS_LAYER_LINE:
flavor = layer.metadata.get("wmm_flavor")
contour_steps = self.get_contour_intervals(
flavor, llbbox, size
)
filename = self.generate_filename("shp")
self.generate_contours(
ds, contour_steps, filename
)
layer.connectiontype = ms.MS_OGR
layer.connection = filename
layer.data, _ = splitext(basename(filename))
datasources.append(filename)
ms_request = ms.create_request((
("service", "WMS"),
("version", "1.3.0"),
("request", "GetMap"),
("layers", ",".join(layers)),
("bbox", "%f,%f,%f,%f" % (bbox[1], bbox[0], bbox[3], bbox[2])),
("crs", crs),
("width", str(size[0])),
("height", str(size[1])),
("styles", ",".join(styles)),
("format", frmt)
))
raw_result = ms.dispatch(map_, ms_request)
result = result_set_from_raw_data(raw_result)
shp_drv = ogr.GetDriverByName("ESRI Shapefile")
# cleanup datasources and datasets
for filename in datasources:
shp_drv.DeleteDataSource(filename)
for ds in datasets:
driver = ds.GetDriver()
for filename in ds.GetFileList():
os.remove(filename)
return result, get_content_type(result)
def render(self, params):
conf = CapabilitiesConfigReader(get_eoxserver_config())
map_ = Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": conf.http_service_url,
"service_onlineresource": conf.onlineresource,
"updateSequence": conf.update_sequence,
"name": conf.name,
"title": conf.title,
"label": conf.title,
"abstract": conf.abstract,
"accessconstraints": conf.access_constraints,
"addresstype": "",
"address": conf.delivery_point,
"stateorprovince": conf.administrative_area,
"city": conf.city,
"postcode": conf.postal_code,
"country": conf.country,
"contactelectronicmailaddress": conf.electronic_mail_address,
"contactfacsimiletelephone": conf.phone_facsimile,
"contactvoicetelephone": conf.phone_voice,
"contactperson": conf.individual_name,
"contactorganization": conf.provider_name,
"contactposition": conf.position_name,
"role": conf.role,
"hoursofservice": conf.hours_of_service,
"contactinstructions": conf.contact_instructions,
"fees": conf.fees,
"keywordlist": ",".join(conf.keywords),
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="ows")
map_.setProjection("EPSG:4326")
for outputformat in self.get_all_outputformats(False):
map_.appendOutputFormat(outputformat)
for coverage in params.coverages:
layer = Layer(coverage.identifier)
layer.setProjection(coverage.spatial_reference.proj)
extent = coverage.extent
size = coverage.size
resolution = ((extent[2] - extent[0]) / float(size[0]),
(extent[1] - extent[3]) / float(size[1]))
layer.setExtent(*extent)
layer.setMetaData({
"title": coverage.identifier,
"label": coverage.identifier,
"extent": "%.10g %.10g %.10g %.10g" % extent,
"resolution": "%.10g %.10g" % resolution,
"size": "%d %d" % size,
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="wcs")
map_.insertLayer(layer)
request = create_request(params)
request.setParameter("version", params.version)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result
def render(self, params):
conf = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(params.http_request)
map_ = Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": http_service_url,
"service_onlineresource": conf.onlineresource,
"updateSequence": conf.update_sequence,
"name": conf.name,
"title": conf.title,
"label": conf.title,
"abstract": conf.abstract,
"accessconstraints": conf.access_constraints,
"addresstype": "",
"address": conf.delivery_point,
"stateorprovince": conf.administrative_area,
"city": conf.city,
"postcode": conf.postal_code,
"country": conf.country,
"contactelectronicmailaddress": conf.electronic_mail_address,
"contactfacsimiletelephone": conf.phone_facsimile,
"contactvoicetelephone": conf.phone_voice,
"contactperson": conf.individual_name,
"contactorganization": conf.provider_name,
"contactposition": conf.position_name,
"role": conf.role,
"hoursofservice": conf.hours_of_service,
"contactinstructions": conf.contact_instructions,
"fees": conf.fees,
"keywordlist": ",".join(conf.keywords),
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="ows")
map_.setProjection("EPSG:4326")
for outputformat in self.get_all_outputformats(False):
map_.appendOutputFormat(outputformat)
for coverage in params.coverages:
layer = Layer(coverage.identifier)
layer.setProjection(coverage.spatial_reference.proj)
extent = coverage.extent
size = coverage.size
resolution = ((extent[2] - extent[0]) / float(size[0]),
(extent[1] - extent[3]) / float(size[1]))
layer.setExtent(*extent)
layer.setMetaData({
"title": coverage.identifier,
"label": coverage.identifier,
"extent": "%.10g %.10g %.10g %.10g" % extent,
"resolution": "%.10g %.10g" % resolution,
"size": "%d %d" % size,
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="wcs")
map_.insertLayer(layer)
request = create_request(params)
request.setParameter("version", params.version)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result
def render(self, params):
# get coverage related stuff
coverage = params.coverage
# ReferenceableDataset are not supported in WCS < 2.0
if issubclass(coverage.real_type, models.ReferenceableDataset):
raise NoSuchCoverageException((coverage.identifier, ))
data_items = self.data_items_for_coverage(coverage)
range_type = coverage.range_type
bands = list(range_type)
subsets = params.subsets
if subsets:
subsets.srid # this automatically checks the validity
# create and configure map object
map_ = self.create_map()
# configure outputformat
native_format = self.get_native_format(coverage, data_items)
if get_format_by_mime(native_format) is None:
native_format = "image/tiff"
frmt = params.format or native_format
if frmt is None:
raise RenderException("Format could not be determined", "format")
mime_type, frmt = split_format(frmt)
imagemode = ms.gdalconst_to_imagemode(bands[0].data_type)
time_stamp = datetime.now().strftime("%Y%m%d%H%M%S")
basename = "%s_%s" % (coverage.identifier, time_stamp)
of = create_outputformat(mime_type, frmt, imagemode, basename,
getattr(params, "encoding_params", {}))
map_.appendOutputFormat(of)
map_.setOutputFormat(of)
# TODO: use layer factory here
layer = self.layer_for_coverage(coverage, native_format,
params.version)
map_.insertLayer(layer)
for connector in self.connectors:
if connector.supports(data_items):
break
else:
raise OperationNotSupportedException(
"Could not find applicable layer connector.", "coverage")
try:
connector.connect(coverage, data_items, layer, {})
# create request object and dispatch it against the map
request = ms.create_request(
self.translate_params(params, range_type))
request.setParameter("format", mime_type)
raw_result = ms.dispatch(map_, request)
finally:
# perform any required layer related cleanup
connector.disconnect(coverage, data_items, layer, {})
result_set = result_set_from_raw_data(raw_result)
if params.version == Version(2, 0):
if getattr(params, "mediatype",
None) in ("multipart/mixed", "multipart/related"):
encoder = WCS20EOXMLEncoder()
is_mosaic = issubclass(coverage.real_type,
models.RectifiedStitchedMosaic)
if not is_mosaic:
tree = encoder.alter_rectified_dataset(
coverage, getattr(params, "http_request", None),
etree.parse(result_set[0].data_file).getroot(),
subsets.bounding_polygon(coverage)
if subsets else None)
else:
tree = encoder.alter_rectified_stitched_mosaic(
coverage.cast(), getattr(params, "http_request", None),
etree.parse(result_set[0].data_file).getroot(),
subsets.bounding_polygon(coverage)
if subsets else None)
result_set[0] = ResultBuffer(encoder.serialize(tree),
encoder.content_type)
# "default" response
return result_set
def render(self, params):
# get coverage related stuff
coverage = params.coverage
# ReferenceableDataset are not supported in WCS < 2.0
if params.coverage.grid.is_referenceable and params.version:
raise NoSuchCoverageException((coverage.identifier, ))
data_locations = self.arraydata_locations_for_coverage(coverage)
range_type = coverage.range_type
bands = list(range_type)
subsets = params.subsets
if subsets:
subsets.srid # this automatically checks the validity
# create and configure map object
map_ = self.create_map()
env = {}
for data_location in data_locations:
env.update(data_location.env)
gdal.set_env(env, False)
# configure outputformat
native_format = self.get_native_format(coverage, data_locations)
if native_format and get_format_by_mime(native_format) is None:
native_format = "image/tiff"
frmt = params.format or native_format
if frmt is None:
raise RenderException("Format could not be determined", "format")
mime_type, frmt = split_format(frmt)
imagemode = ms.gdalconst_to_imagemode(bands[0].data_type)
time_stamp = datetime.now().strftime("%Y%m%d%H%M%S")
basename = "%s_%s" % (coverage.identifier, time_stamp)
of = create_outputformat(mime_type, frmt, imagemode, basename,
getattr(params, "encoding_params", {}))
map_.appendOutputFormat(of)
map_.setOutputFormat(of)
# TODO: use layer factory here
layer = self.layer_for_coverage(coverage, native_format,
params.version)
map_.insertLayer(layer)
connector = get_connector_by_test(coverage, data_locations)
if not connector:
raise OperationNotSupportedException(
"Could not find applicable layer connector.", "coverage")
try:
connector.connect(coverage, data_locations, layer, {})
# create request object and dispatch it against the map
request = ms.create_request(
self.translate_params(params, range_type))
request.setParameter("format", mime_type)
raw_result = ms.dispatch(map_, request)
finally:
# perform any required layer related cleanup
connector.disconnect(coverage, data_locations, layer, {})
result_set = result_set_from_raw_data(raw_result)
if params.version == Version(2, 0):
mediatype = getattr(params, "mediatype", None)
if mediatype in ("multipart/mixed", "multipart/related"):
with vsi.TemporaryVSIFile.from_buffer(result_set[1].data) as f:
ds = gdal.Open(f.name)
grid = objects.Grid.from_gdal_dataset(ds)
# get the output CRS definition
crs = params.outputcrs or subsets.crs or 'imageCRS'
if crs == 'imageCRS':
crs = coverage.grid.coordinate_reference_system
grid._coordinate_reference_system = crs
origin = objects.Origin.from_gdal_dataset(ds)
size = [ds.RasterXSize, ds.RasterYSize]
range_type = coverage.range_type
if params.rangesubset:
range_type = range_type.subset(params.rangesubset)
coverage._grid = grid
coverage._origin = origin
coverage._size = size
coverage._range_type = range_type
if isinstance(result_set[1].filename, binary_type):
file_name = result_set[1].filename.decode()
else:
file_name = result_set[1].filename
reference = 'cid:coverage/%s' % file_name
encoder = WCS20EOXMLEncoder()
if not isinstance(coverage, objects.Mosaic):
tree = encoder.encode_rectified_dataset(
coverage, getattr(params, "http_request", None),
reference, mime_type,
subsets.bounding_polygon(coverage)
if subsets else None)
else:
tree = encoder.encode_rectified_stitched_mosaic(
coverage, getattr(params, "http_request", None),
reference, mime_type,
subsets.bounding_polygon(coverage)
if subsets else None)
result_set[0] = ResultBuffer(encoder.serialize(tree),
encoder.content_type)
# "default" response
return result_set
def dispatch(map_, request):
""" Wraps the ``OWSDispatch`` method. Perfoms all necessary steps for a
further handling of the result.
"""
logger.debug("MapServer: Installing stdout to buffer.")
msIO_installStdoutToBuffer()
# write the map if debug is enabled
if logger.isEnabledFor(logging.DEBUG):
fd, filename = tempfile.mkstemp(text=True)
try:
with os.fdopen(fd) as f:
map_.save(filename)
logger.debug(f.read())
finally:
os.remove(filename)
try:
logger.debug("MapServer: Dispatching.")
ts = time.time()
# Execute the OWS request by mapserver, obtain the status in
# dispatch_status (0 is OK)
status = map_.OWSDispatch(request)
te = time.time()
logger.debug("MapServer: Dispatch took %f seconds." % (te - ts))
except Exception as e:
raise MapServerException(str(e), "NoApplicableCode")
raw_bytes = msIO_getStdoutBufferBytes()
# check whether an error occurred
if status != 0:
# First try to get the error message through the error object
obj = msGetErrorObj()
if obj and obj.message:
raise MapServerException(obj.message, obj.code)
try:
# try to parse the output as XML
result = result_set_from_raw_data(raw_bytes)
tree = etree.fromstring(result[0].data)
exception_elem = tree.xpath(
"*[local-name() = 'Exception']|*[local-name() = 'ServiceException']"
)[0]
locator = exception_elem.attrib.get("locator")
code = exception_elem.attrib.get("exceptionCode")
message = exception_elem[0].text
raise MapServerException(message, locator, code)
except (etree.XMLSyntaxError, IndexError, KeyError):
pass
# Fallback: raise arbitrary error
raise MapServerException("Unexpected Error.", "NoApplicableCode")
logger.debug("MapServer: Performing MapServer cleanup.")
# Workaround for MapServer issue #4369
if msversion < 60004 or (msversion < 60200 and msversion >= 60100):
msCleanup()
else:
msIO_resetHandlers()
return raw_bytes
def render(self, params):
conf = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(params.http_request)
map_ = Map()
map_.setMetaData(
{
"enable_request":
"*",
"onlineresource":
http_service_url,
"service_onlineresource":
conf.onlineresource,
"updateSequence":
conf.update_sequence,
"name":
conf.name,
"title":
conf.title,
"label":
conf.title,
"abstract":
conf.abstract,
"accessconstraints":
conf.access_constraints,
"addresstype":
"",
"address":
conf.delivery_point,
"stateorprovince":
conf.administrative_area,
"city":
conf.city,
"postcode":
conf.postal_code,
"country":
conf.country,
"contactelectronicmailaddress":
conf.electronic_mail_address,
"contactfacsimiletelephone":
conf.phone_facsimile,
"contactvoicetelephone":
conf.phone_voice,
"contactperson":
conf.individual_name,
"contactorganization":
conf.provider_name,
"contactposition":
conf.position_name,
"role":
conf.role,
"hoursofservice":
conf.hours_of_service,
"contactinstructions":
conf.contact_instructions,
"fees":
conf.fees,
"keywordlist":
",".join(conf.keywords),
"formats":
" ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="ows")
map_.setProjection("EPSG:4326")
for outputformat in self.get_all_outputformats(False):
map_.appendOutputFormat(outputformat)
for coverage in params.coverages:
layer = Layer(coverage.identifier)
render_coverage = Coverage.from_model(coverage)
layer.setProjection(render_coverage.grid.spatial_reference.proj)
extent = render_coverage.extent
size = render_coverage.size
resolution = ((extent[2] - extent[0]) / float(size[0]),
(extent[1] - extent[3]) / float(size[1]))
layer.setExtent(*extent)
layer.setMetaData(
{
"title":
coverage.identifier,
"label":
coverage.identifier,
"extent":
"%.10g %.10g %.10g %.10g" % extent,
"resolution":
"%.10g %.10g" % resolution,
"size":
"%d %d" % size,
"formats":
" ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="wcs")
map_.insertLayer(layer)
request = create_request(params)
request.setParameter("version", params.version)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
xml_result = etree.fromstring(result[0].data)
for elem in xml_result.xpath('//*[local-name() = "metadataLink"]'):
elem.getparent().remove(elem)
# Add CQL parameter to GetCapabilities operation
for elem in xml_result.xpath(
'//*[local-name() = "Operation"][@name = "GetCapabilities"]'):
ows = elem.nsmap['ows']
param = etree.SubElement(elem, '{%s}Parameter' % ows)
param.attrib['name'] = 'cql'
etree.SubElement(param, '{%s}AnyValue' % ows)
xml_result_data = etree.tostring(xml_result,
pretty_print=True,
encoding='UTF-8',
xml_declaration=True)
result[0] = ResultBuffer(xml_result_data, result[0].content_type)
return result
