def encode_service_metadata(self): service_metadata = WCS("ServiceMetadata") # get the list of enabled formats from the format registry formats = filter(lambda f: f, getFormatRegistry().getSupportedFormatsWCS()) service_metadata.extend( map(lambda f: WCS("formatSupported", f.mimeType), formats)) # get a list of supported CRSs from the CRS registry supported_crss = crss.getSupportedCRS_WCS(format_function=crss.asURL) extension = WCS("Extension") service_metadata.append(extension) crs_metadata = CRS("CrsMetadata") extension.append(crs_metadata) crs_metadata.extend( map(lambda c: CRS("crsSupported", c), supported_crss)) base_url = "http://www.opengis.net/def/interpolation/OGC/1/" extension.append( INT( "InterpolationMetadata", *[ INT("InterpolationSupported", base_url + supported_interpolation) for supported_interpolation in SUPPORTED_INTERPOLATIONS ])) return service_metadata
def encode_service_metadata(self): service_metadata = WCS("ServiceMetadata") # get the list of enabled formats from the format registry formats = filter( lambda f: f, getFormatRegistry().getSupportedFormatsWCS() ) service_metadata.extend( map(lambda f: WCS("formatSupported", f.mimeType), formats) ) # get a list of supported CRSs from the CRS registry supported_crss = crss.getSupportedCRS_WCS( format_function=crss.asURL ) extension = WCS("Extension") service_metadata.append(extension) crs_metadata = CRS("CrsMetadata") extension.append(crs_metadata) crs_metadata.extend( map(lambda c: CRS("crsSupported", c), supported_crss) ) base_url = "http://www.opengis.net/def/interpolation/OGC/1/" extension.append( INT("InterpolationMetadata", *[ INT("InterpolationSupported", base_url + supported_interpolation ) for supported_interpolation in SUPPORTED_INTERPOLATIONS ]) ) return service_metadata
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 layer_for_coverage(self, coverage, native_format, version=None): """ Helper method to generate a WCS enabled MapServer layer for a given coverage. """ range_type = coverage.range_type bands = list(range_type) coverage_identifier = coverage.identifier if version and version.startswith('2'): try: models.identifier_validators[0](coverage_identifier) except Exception: coverage_identifier = 'not-ncname' # create and configure layer layer = ms.layerObj() layer.name = coverage_identifier layer.type = ms.MS_LAYER_RASTER sr = coverage.grid.spatial_reference layer.setProjection(sr.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) ms.setMetaData(layer, { "title": coverage_identifier, "enable_request": "*" }, namespace="ows") data_type = bands[0].data_type if bands[0].allowed_values: interval = bands[0].allowed_values[0] else: interval = gdal.GDT_NUMERIC_LIMITS[data_type] if bands[0].significant_figures is not None: significant_figures = bands[0].significant_figures else: significant_figures = gdal.GDT_SIGNIFICANT_FIGURES[data_type] ms.setMetaData(layer, { "label": coverage_identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "bandcount": str(len(bands)), "interval": "%f %f" % interval, "significant_figures": "%d" % significant_figures, "rangeset_name": range_type.name, "rangeset_label": range_type.name, "imagemode": ms.gdalconst_to_imagemode_string(bands[0].data_type), "formats": " ".join([ f.wcs10name if version.startswith("1.0") else f.mimeType for f in self.get_wcs_formats() ]) }, namespace="wcs") if version is None or version.startswith("2.0"): ms.setMetaData( layer, { "band_names": " ".join([band.identifier for band in bands]), }, namespace="wcs") else: ms.setMetaData( layer, { "rangeset_axes": ",".join(band.identifier for band in bands), }, namespace="wcs") if native_format: if version.startswith("1.0"): native_format = next( (x.wcs10name for x in self.get_wcs_formats() if x.mimeType == native_format), native_format) ms.setMetaData(layer, { "native_format": native_format, "nativeformat": native_format }, namespace="wcs") native_crs = "EPSG:%d" % sr.srid all_crss = list( crss.getSupportedCRS_WCS(format_function=crss.asShortCode)) if native_crs in all_crss: all_crss.remove(native_crs) # setting the coverages CRS as the first one is important! all_crss.insert(0, native_crs) supported_crss = " ".join(all_crss) layer.setMetaData("ows_srs", supported_crss) layer.setMetaData("wcs_srs", supported_crss) for band in bands: ms.setMetaData(layer, { "band_description": band.description, "band_definition": band.definition, "band_uom": band.unit_of_measure, }, namespace=band.identifier) if band.allowed_values: interval = band.allowed_values[0] else: interval = gdal.GDT_NUMERIC_LIMITS[band.data_type] # For MS WCS 1.x interface ms.setMetaData(layer, { "label": band.identifier, "interval": "%d %d" % interval }, namespace="wcs_%s" % band.identifier) if bands[0].nil_values: nilvalues, nilvalues_reasons = zip( *[[nv[0], nv[1]] for nv in bands[0].nil_values]) if nilvalues: ms.setMetaData(layer, { "nilvalues": " ".join(nilvalues), "nilvalues_reasons": " ".join(nilvalues_reasons) }, namespace="wcs") return layer
def layer_for_coverage(self, coverage, native_format, version=None): """ Helper method to generate a WCS enabled MapServer layer for a given coverage. """ range_type = coverage.range_type bands = list(range_type) # create and configure layer layer = ms.layerObj() layer.name = coverage.identifier layer.type = ms.MS_LAYER_RASTER 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) ms.setMetaData(layer, { "title": coverage.identifier, "enable_request": "*" }, namespace="ows") ms.setMetaData(layer, { "label": coverage.identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "bandcount": str(len(bands)), "interval": "%f %f" % bands[0].allowed_values, "significant_figures": "%d" % bands[0].significant_figures, "rangeset_name": range_type.name, "rangeset_label": range_type.name, "imagemode": ms.gdalconst_to_imagemode_string(bands[0].data_type), "formats": " ".join([ f.wcs10name if version.startswith("1.0") else f.mimeType for f in self.get_wcs_formats()] ) }, namespace="wcs") if version is None or version.startswith("2.0"): ms.setMetaData(layer, { "band_names": " ".join([band.name for band in bands]), }, namespace="wcs") else: ms.setMetaData(layer, { "rangeset_axes": ",".join(band.name for band in bands), }, namespace="wcs") if native_format: if version.startswith("1.0"): native_format = next(( x.wcs10name for x in self.get_wcs_formats() if x.mimeType == native_format), native_format ) ms.setMetaData(layer, { "native_format": native_format, "nativeformat": native_format }, namespace="wcs") native_crs = "EPSG:%d" % coverage.spatial_reference.srid all_crss = crss.getSupportedCRS_WCS(format_function=crss.asShortCode) if native_crs in all_crss: all_crss.remove(native_crs) # setting the coverages CRS as the first one is important! all_crss.insert(0, native_crs) supported_crss = " ".join(all_crss) layer.setMetaData("ows_srs", supported_crss) layer.setMetaData("wcs_srs", supported_crss) for band in bands: ms.setMetaData(layer, { "band_description": band.description, "band_definition": band.definition, "band_uom": band.uom, }, namespace=band.name) # For MS WCS 1.x interface ms.setMetaData(layer, { "label": band.name, "interval": "%d %d" % band.allowed_values }, namespace="wcs_%s" % band.name) if bands[0].nil_value_set: nilvalues = " ".join( str(nil_value.value) for nil_value in bands[0].nil_value_set ) nilvalues_reasons = " ".join( nil_value.reason for nil_value in bands[0].nil_value_set ) if nilvalues: ms.setMetaData(layer, { "nilvalues": nilvalues, "nilvalues_reasons": nilvalues_reasons }, namespace="wcs") return layer
def layer_for_coverage(self, coverage, native_format, version=None): """ Helper method to generate a WCS enabled MapServer layer for a given coverage. """ range_type = coverage.range_type bands = list(range_type) # create and configure layer layer = ms.layerObj() layer.name = coverage.identifier layer.type = ms.MS_LAYER_RASTER 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) ms.setMetaData(layer, { "title": coverage.identifier, "enable_request": "*" }, namespace="ows") ms.setMetaData(layer, { "label": coverage.identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "bandcount": str(len(bands)), "interval": "%f %f" % bands[0].allowed_values, "significant_figures": "%d" % bands[0].significant_figures, "rangeset_name": range_type.name, "rangeset_label": range_type.name, "imagemode": ms.gdalconst_to_imagemode_string(bands[0].data_type), "formats": " ".join([ f.wcs10name if version.startswith("1.0") else f.mimeType for f in self.get_wcs_formats() ]) }, namespace="wcs") if version is None or version.startswith("2.0"): ms.setMetaData( layer, { "band_names": " ".join([band.name for band in bands]), }, namespace="wcs") else: ms.setMetaData( layer, { "rangeset_axes": ",".join(band.name for band in bands), }, namespace="wcs") if native_format: if version.startswith("1.0"): native_format = next( (x.wcs10name for x in self.get_wcs_formats() if x.mimeType == native_format), native_format) ms.setMetaData(layer, { "native_format": native_format, "nativeformat": native_format }, namespace="wcs") native_crs = "EPSG:%d" % coverage.spatial_reference.srid all_crss = crss.getSupportedCRS_WCS(format_function=crss.asShortCode) if native_crs in all_crss: all_crss.remove(native_crs) # setting the coverages CRS as the first one is important! all_crss.insert(0, native_crs) supported_crss = " ".join(all_crss) layer.setMetaData("ows_srs", supported_crss) layer.setMetaData("wcs_srs", supported_crss) for band in bands: ms.setMetaData(layer, { "band_description": band.description, "band_definition": band.definition, "band_uom": band.uom, }, namespace=band.name) # For MS WCS 1.x interface ms.setMetaData(layer, { "label": band.name, "interval": "%d %d" % band.allowed_values }, namespace="wcs_%s" % band.name) if bands[0].nil_value_set: nilvalues = " ".join( str(nil_value.value) for nil_value in bands[0].nil_value_set) nilvalues_reasons = " ".join( nil_value.reason for nil_value in bands[0].nil_value_set) if nilvalues: ms.setMetaData(layer, { "nilvalues": nilvalues, "nilvalues_reasons": nilvalues_reasons }, namespace="wcs") return layer
def encode_capabilities(self, sections, coverages_qs=None, dataset_series_qs=None): conf = CapabilitiesConfigReader(get_eoxserver_config()) all_sections = "all" in sections caps = [] if all_sections or "serviceidentification" in sections: caps.append( OWS("ServiceIdentification", OWS("Title", conf.title), OWS("Abstract", conf.abstract), OWS("Keywords", *[ OWS("Keyword", keyword) for keyword in conf.keywords ]), OWS("ServiceType", "OGC WCS", codeSpace="OGC"), OWS("ServiceTypeVersion", "2.0.1"), OWS("Profile", "http://www.opengis.net/spec/WCS_application-profile_earth-observation/1.0/conf/eowcs"), OWS("Profile", "http://www.opengis.net/spec/WCS_application-profile_earth-observation/1.0/conf/eowcs_get-kvp"), OWS("Profile", "http://www.opengis.net/spec/WCS_service-extension_crs/1.0/conf/crs"), OWS("Profile", "http://www.opengis.net/spec/WCS/2.0/conf/core"), OWS("Profile", "http://www.opengis.net/spec/WCS_protocol-binding_get-kvp/1.0/conf/get-kvp"), OWS("Profile", "http://www.opengis.net/spec/WCS_protocol-binding_post-xml/1.0/conf/post-xml"), OWS("Profile", "http://www.opengis.net/spec/GMLCOV/1.0/conf/gml-coverage"), OWS("Profile", "http://www.opengis.net/spec/GMLCOV/1.0/conf/multipart"), OWS("Profile", "http://www.opengis.net/spec/GMLCOV/1.0/conf/special-format"), OWS("Profile", "http://www.opengis.net/spec/GMLCOV_geotiff-coverages/1.0/conf/geotiff-coverage"), OWS("Profile", "http://www.opengis.net/spec/WCS_geotiff-coverages/1.0/conf/geotiff-coverage"), OWS("Profile", "http://www.opengis.net/spec/WCS_service-model_crs-predefined/1.0/conf/crs-predefined"), OWS("Profile", "http://www.opengis.net/spec/WCS_service-model_scaling+interpolation/1.0/conf/scaling+interpolation"), OWS("Profile", "http://www.opengis.net/spec/WCS_service-model_band-subsetting/1.0/conf/band-subsetting"), OWS("Fees", conf.fees), OWS("AccessConstraints", conf.access_constraints) ) ) if all_sections or "serviceprovider" in sections: caps.append( OWS("ServiceProvider", OWS("ProviderName", conf.provider_name), self.encode_reference("ProviderSite", conf.provider_site), OWS("ServiceContact", OWS("IndividualName", conf.individual_name), OWS("PositionName", conf.position_name), OWS("ContactInfo", OWS("Phone", OWS("Voice", conf.phone_voice), OWS("Facsimile", conf.phone_facsimile) ), OWS("Address", OWS("DeliveryPoint", conf.delivery_point), OWS("City", conf.city), OWS("AdministrativeArea", conf.administrative_area), OWS("PostalCode", conf.postal_code), OWS("Country", conf.country), OWS("ElectronicMailAddress", conf.electronic_mail_address) ), self.encode_reference( "OnlineResource", conf.onlineresource ), OWS("HoursOfService", conf.hours_of_service), OWS("ContactInstructions", conf.contact_instructions) ), OWS("Role", conf.role) ) ) ) if all_sections or "operationsmetadata" in sections: component = ServiceComponent(env) versions = ("2.0.0", "2.0.1") get_handlers = component.query_service_handlers( service="WCS", versions=versions, method="GET" ) post_handlers = component.query_service_handlers( service="WCS", versions=versions, method="POST" ) all_handlers = sorted( set(get_handlers + post_handlers), key=lambda h: h.request ) operations = [] for handler in all_handlers: methods = [] if handler in get_handlers: methods.append( self.encode_reference("Get", conf.http_service_url) ) if handler in post_handlers: post = self.encode_reference("Post", conf.http_service_url) post.append( OWS("Constraint", OWS("AllowedValues", OWS("Value", "XML") ), name="PostEncoding" ) ) methods.append(post) operations.append( OWS("Operation", OWS("DCP", OWS("HTTP", *methods) ), # apply default values as constraints *[ OWS("Constraint", OWS("NoValues"), OWS("DefaultValue", str(default)), name=name ) for name, default in getattr(handler, "constraints", {}).items() ], name=handler.request ) ) caps.append(OWS("OperationsMetadata", *operations)) if all_sections or "servicemetadata" in sections: service_metadata = WCS("ServiceMetadata") # get the list of enabled formats from the format registry formats = filter( lambda f: f, getFormatRegistry().getSupportedFormatsWCS() ) service_metadata.extend( map(lambda f: WCS("formatSupported", f.mimeType), formats) ) # get a list of supported CRSs from the CRS registry supported_crss = crss.getSupportedCRS_WCS(format_function=crss.asURL) extension = WCS("Extension") service_metadata.append(extension) extension.extend( map(lambda c: CRS("crsSupported", c), supported_crss) ) caps.append(service_metadata) inc_contents = all_sections or "contents" in sections inc_coverage_summary = inc_contents or "coveragesummary" in sections inc_dataset_series_summary = inc_contents or "datasetseriessummary" in sections inc_contents = inc_contents or inc_coverage_summary or inc_dataset_series_summary if inc_contents: contents = [] if inc_coverage_summary: coverages = [] # reduce data transfer by only selecting required elements # TODO: currently runs into a bug #coverages_qs = coverages_qs.only( # "identifier", "real_content_type" #) for coverage in coverages_qs: coverages.append( WCS("CoverageSummary", WCS("CoverageId", coverage.identifier), WCS("CoverageSubtype", coverage.real_type.__name__) ) ) contents.extend(coverages) if inc_dataset_series_summary: dataset_series_set = [] # reduce data transfer by only selecting required elements # TODO: currently runs into a bug #dataset_series_qs = dataset_series_qs.only( # "identifier", "begin_time", "end_time", "footprint" #) for dataset_series in dataset_series_qs: minx, miny, maxx, maxy = dataset_series.extent_wgs84 dataset_series_set.append( EOWCS("DatasetSeriesSummary", OWS("WGS84BoundingBox", OWS("LowerCorner", "%f %f" % (miny, minx)), OWS("UpperCorner", "%f %f" % (maxy, maxx)), ), EOWCS("DatasetSeriesId", dataset_series.identifier), GML("TimePeriod", GML("beginPosition", isoformat(dataset_series.begin_time)), GML("endPosition", isoformat(dataset_series.end_time)), **{ns_gml("id"): dataset_series.identifier + "_timeperiod"} ) ) ) contents.append(WCS("Extension", *dataset_series_set)) caps.append(WCS("Contents", *contents)) root = WCS("Capabilities", *caps, version="2.0.1", updateSequence=conf.update_sequence) return root
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) 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
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, 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)