def encode_rectified_grid(self, size, extent, sr, grid_name): size_x, size_y = size minx, miny, maxx, maxy = extent srs_name = sr.url swap = crss.getAxesSwapper(sr.srid) frmt = "%.3f %.3f" if sr.IsProjected() else "%.8f %.8f" labels = ("x", "y") if sr.IsProjected() else ("long", "lat") axis_labels = " ".join(swap(*labels)) origin = frmt % swap(minx, maxy) x_offsets = frmt % swap((maxx - minx) / float(size_x), 0) y_offsets = frmt % swap(0, (miny - maxy) / float(size_y)) return GML( "RectifiedGrid", GML("limits", self.encode_grid_envelope(0, 0, size_x - 1, size_y - 1)), GML("axisLabels", axis_labels), GML( "origin", GML( "Point", GML("pos", origin), **{ ns_gml("id"): self.get_gml_id("%s_origin" % grid_name), "srsName": srs_name })), GML("offsetVector", x_offsets, srsName=srs_name), GML("offsetVector", y_offsets, srsName=srs_name), **{ ns_gml("id"): self.get_gml_id(grid_name), "dimension": "2" })
def encode_rectified_grid(self, size, extent, sr, grid_name): size_x, size_y = size minx, miny, maxx, maxy = extent srs_name = sr.url swap = crss.getAxesSwapper(sr.srid) frmt = "%.3f %.3f" if sr.IsProjected() else "%.8f %.8f" labels = ("x", "y") if sr.IsProjected() else ("long", "lat") axis_labels = " ".join(swap(*labels)) origin = frmt % swap(minx, maxy) x_offsets = frmt % swap((maxx - minx) / float(size_x), 0) y_offsets = frmt % swap(0, (miny - maxy) / float(size_y)) return GML("RectifiedGrid", GML("limits", self.encode_grid_envelope(0, 0, size_x - 1, size_y - 1) ), GML("axisLabels", axis_labels), GML("origin", GML("Point", GML("pos", origin), **{ ns_gml("id"): self.get_gml_id("%s_origin" % grid_name), "srsName": srs_name } ) ), GML("offsetVector", x_offsets, srsName=srs_name), GML("offsetVector", y_offsets, srsName=srs_name), **{ ns_gml("id"): self.get_gml_id(grid_name), "dimension": "2" } )
def encode_earth_observation(self, eo_metadata, contributing_datasets=None, subset_polygon=None): identifier = eo_metadata.identifier begin_time = eo_metadata.begin_time end_time = eo_metadata.end_time result_time = eo_metadata.end_time footprint = eo_metadata.footprint if subset_polygon is not None: footprint = footprint.intersection(subset_polygon) return EOP("EarthObservation", OM("phenomenonTime", self.encode_time_period(begin_time, end_time, "phen_time_%s" % identifier) ), OM("resultTime", self.encode_time_instant(result_time, "res_time_%s" % identifier) ), OM("procedure"), OM("observedProperty"), OM("featureOfInterest", self.encode_footprint(footprint, identifier) ), OM("result"), self.encode_metadata_property(identifier, contributing_datasets), **{ns_gml("id"): "eop_%s" % identifier} )
def encode_contents(self, coverages_qs, dataset_series_qs): contents = [] if coverages_qs: 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 dataset_series_qs: 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)) return WCS("Contents", *contents)
def encode_dataset_series_description(self, dataset_series): return EOWCS( "DatasetSeriesDescription", self.encode_bounded_by(dataset_series.extent_wgs84), EOWCS("DatasetSeriesId", dataset_series.identifier), self.encode_time_period( dataset_series.begin_time, dataset_series.end_time, "%s_timeperiod" % dataset_series.identifier), **{ns_gml("id"): self.get_gml_id(dataset_series.identifier)})
def encode_rectified_grid(self, grid, coverage, name): axis_names = [axis.name for axis in grid] offsets = [axis.offset for axis in grid] origin = coverage.origin sr = SpatialReference(grid.coordinate_reference_system) url = sr.url frmt = "%.3f" if sr.IsProjected() else "%.8f" offset_vectors = [ GML("offsetVector", " ".join([frmt % 0.0] * i + [frmt % offset] + [frmt % 0.0] * (len(offsets) - i - 1)), srsName=url) for i, offset in enumerate(offsets) ] if crss.hasSwappedAxes(sr.srid): axis_names[0:2] = [axis_names[1], axis_names[0]] # offset_vectors[0:2] = [offset_vectors[1], offset_vectors[0]] for offset_vector in offset_vectors[0:2]: parts = offset_vector.text.split(" ") parts[0:2] = reversed(parts[0:2]) offset_vector.text = " ".join(parts) origin[0:2] = [origin[1], origin[0]] origin_str = " ".join(["%.3f" if sr.IsProjected() else "%.8f"] * len(origin)) % tuple(origin) return GML( "RectifiedGrid", GML("limits", self.encode_grid_envelope(coverage.size)), GML("axisLabels", " ".join(axis_names)), GML( "origin", GML( "Point", GML("pos", origin_str), **{ ns_gml("id"): self.get_gml_id("%s_origin" % name), "srsName": url })), *offset_vectors, **{ ns_gml("id"): self.get_gml_id(name), "dimension": "2" })
def encode_polygon(self, polygon, base_id): return GML("Polygon", GML("exterior", self.encode_linear_ring(polygon[0], polygon.srs) ), *(GML("interior", self.encode_linear_ring(interior, polygon.srs) ) for interior in polygon[1:]), **{ns_gml("id"): "polygon_%s" % base_id} )
def encode_coverage_description(self, coverage): grid = coverage.grid return WCS( "CoverageDescription", self.encode_bounded_by(coverage, grid), WCS("CoverageId", coverage.identifier), self.encode_domain_set(coverage, rectified=(grid is not None)), self.encode_range_type(coverage.range_type), WCS("ServiceParameters", WCS("CoverageSubtype", self.get_coverage_subtype(coverage))), **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
def encode_dataset_series_description(self, dataset_series): return EOWCS("DatasetSeriesDescription", self.encode_bounded_by(dataset_series.extent_wgs84), EOWCS("DatasetSeriesId", dataset_series.identifier), self.encode_time_period( dataset_series.begin_time, dataset_series.end_time, "%s_timeperiod" % dataset_series.identifier ), **{ns_gml("id"): self.get_gml_id(dataset_series.identifier)} )
def encode_coverage_description(self, coverage, srid=None, size=None, extent=None, footprint=None): source_mime = None for arraydata_location in getattr(coverage, 'arraydata_locations', []): if arraydata_location.format: source_mime = arraydata_location.format break native_format = None if source_mime: source_format = getFormatRegistry().getFormatByMIME(source_mime) # map the source format to the native one native_format = getFormatRegistry().mapSourceToNativeWCS20( source_format) # elif issubclass(coverage.real_type, RectifiedStitchedMosaic): # # use the default format for RectifiedStitchedMosaics # native_format = getFormatRegistry().getDefaultNativeFormat() # else: # # TODO: improve if no native format availabe # native_format = None sr = SpatialReference(4326) if extent: poly = Polygon.from_bbox(extent) poly.srid = srid extent = poly.transform(4326).extent else: # extent = coverage.extent extent = (0, 0, 1, 1) # sr = coverage.spatial_reference # if issubclass(coverage.real_type, ReferenceableDataset): # rectified = False # else: # rectified = True rectified = (coverage.grid is not None) return WCS( "CoverageDescription", self.encode_bounded_by(coverage, coverage.grid), WCS("CoverageId", coverage.identifier), self.encode_eo_metadata(coverage), self.encode_domain_set(coverage, srid, size, extent, rectified), self.encode_range_type(coverage.range_type), WCS( "ServiceParameters", WCS("CoverageSubtype", self.get_coverage_subtype(coverage)), WCS("nativeFormat", native_format.mimeType if native_format else "")), **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
def encode_coverage_description(self, coverage): rectified = False if issubclass(coverage.real_type, ReferenceableDataset) else True return WCS( "CoverageDescription", self.encode_bounded_by(coverage.extent_wgs84), WCS("CoverageId", coverage.identifier), self.encode_domain_set(coverage, rectified=rectified), self.encode_range_type(self.get_range_type(coverage.range_type_id)), WCS("ServiceParameters", WCS("CoverageSubtype", coverage.real_type.__name__)) ** {ns_gml("id"): self.get_gml_id(coverage.identifier)}, )
def encode_referenceable_grid(self, size, sr, grid_name): size_x, size_y = size swap = crss.getAxesSwapper(sr.srid) labels = ("x", "y") if sr.IsProjected() else ("long", "lat") axis_labels = " ".join(swap(*labels)) return GML( "ReferenceableGrid", GML("limits", self.encode_grid_envelope(0, 0, size_x - 1, size_y - 1)), GML("axisLabels", axis_labels), **{ns_gml("id"): self.get_gml_id(grid_name), "dimension": "2"} )
def encode_contents(self, coverages_qs, dataset_series_qs): contents = [] if coverages_qs: 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 dataset_series_qs: 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)) return WCS("Contents", *contents)
def encode_contents(self, coverages, dataset_series_set): contents = [] if coverages is not None: contents.extend([ WCS( "CoverageSummary", WCS("CoverageId", coverage.identifier), WCS("CoverageSubtype", self.get_coverage_subtype(coverage))) for coverage in coverages ]) if dataset_series_set is not None: dataset_series_elements = [] for dataset_series in dataset_series_set: footprint = dataset_series.footprint dataset_series_summary = EOWCS("DatasetSeriesSummary") # NOTE: non-standard, ows:WGS84BoundingBox is actually mandatory, # but not available for e.g: empty collections if footprint: minx, miny, maxx, maxy = footprint.extent dataset_series_summary.append( OWS( "WGS84BoundingBox", OWS("LowerCorner", "%f %f" % (miny, minx)), OWS("UpperCorner", "%f %f" % (maxy, maxx)), )) dataset_series_summary.append( EOWCS("DatasetSeriesId", dataset_series.identifier)) # NOTE: non-standard, gml:TimePosition is actually mandatory, # but not available for e.g: empty collections if dataset_series.begin_time and dataset_series.end_time: dataset_series_summary.append( GML( "TimePeriod", GML("beginPosition", isoformat(dataset_series.begin_time)), GML("endPosition", isoformat(dataset_series.end_time)), **{ ns_gml("id"): dataset_series.identifier + "_timeperiod" })) dataset_series_elements.append(dataset_series_summary) if dataset_series_elements: contents.append(WCS("Extension", *dataset_series_elements)) return WCS("Contents", *contents)
def encode_coverage_description(self, coverage, srid=None, size=None, extent=None, footprint=None): source_mime = None band_items = coverage.data_items.filter(semantic__startswith="bands") for data_item in band_items: if data_item.format: source_mime = data_item.format break if source_mime: source_format = getFormatRegistry().getFormatByMIME(source_mime) # map the source format to the native one native_format = getFormatRegistry().mapSourceToNativeWCS20( source_format) elif issubclass(coverage.real_type, RectifiedStitchedMosaic): # use the default format for RectifiedStitchedMosaics native_format = getFormatRegistry().getDefaultNativeFormat() else: # TODO: improve if no native format availabe native_format = None if extent: poly = Polygon.from_bbox(extent) poly.srid = srid extent = poly.transform(4326).extent sr = SpatialReference(4326) else: extent = coverage.extent sr = coverage.spatial_reference if issubclass(coverage.real_type, ReferenceableDataset): rectified = False else: rectified = True return WCS( "CoverageDescription", self.encode_bounded_by(extent, sr), WCS("CoverageId", coverage.identifier), self.encode_eo_metadata(coverage), self.encode_domain_set(coverage, srid, size, extent, rectified), self.encode_range_type(self.get_range_type( coverage.range_type_id)), WCS( "ServiceParameters", WCS("CoverageSubtype", coverage.real_type.__name__), WCS("nativeFormat", native_format.mimeType if native_format else "")), **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
def encode_referenceable_grid(self, size, sr, grid_name): size_x, size_y = size swap = crss.getAxesSwapper(sr.srid) labels = ("x", "y") if sr.IsProjected() else ("long", "lat") axis_labels = " ".join(swap(*labels)) return GML( "ReferenceableGrid", GML("limits", self.encode_grid_envelope([size_x - 1, size_y - 1])), GML("axisLabels", axis_labels), **{ ns_gml("id"): self.get_gml_id(grid_name), "dimension": "2" })
def encode_coverage_description(self, coverage, srid=None, size=None, extent=None, footprint=None): source_mime = None band_items = coverage.data_items.filter(semantic__startswith="bands") for data_item in band_items: if data_item.format: source_mime = data_item.format break if source_mime: source_format = getFormatRegistry().getFormatByMIME(source_mime) # map the source format to the native one native_format = getFormatRegistry().mapSourceToNativeWCS20( source_format ) elif issubclass(coverage.real_type, RectifiedStitchedMosaic): # use the default format for RectifiedStitchedMosaics native_format = getFormatRegistry().getDefaultNativeFormat() else: # TODO: improve if no native format availabe native_format = None if extent: poly = Polygon.from_bbox(extent) poly.srid = srid extent = poly.transform(4326).extent sr = SpatialReference(4326) else: extent = coverage.extent sr = coverage.spatial_reference if issubclass(coverage.real_type, ReferenceableDataset): rectified = False else: rectified = True return WCS("CoverageDescription", self.encode_bounded_by(extent, sr), WCS("CoverageId", coverage.identifier), self.encode_eo_metadata(coverage), self.encode_domain_set(coverage, srid, size, extent, rectified), self.encode_range_type(self.get_range_type(coverage.range_type_id)), WCS("ServiceParameters", WCS("CoverageSubtype", coverage.real_type.__name__), WCS( "nativeFormat", native_format.mimeType if native_format else "" ) ), **{ns_gml("id"): self.get_gml_id(coverage.identifier)} )
def encode_rectified_dataset(self, coverage, request, reference, mime_type, subset_polygon=None): return EOWCS( "RectifiedDataset", self.encode_bounded_by(coverage, coverage.grid), self.encode_domain_set(coverage, rectified=True), self.encode_range_set(reference, mime_type), self.encode_range_type(coverage.range_type), self.encode_eo_metadata(coverage, request, subset_polygon), **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
def encode_multi_surface(self, geom, base_id): if geom.geom_typeid in (6, 7): # MultiPolygon and GeometryCollection polygons = [ self.encode_polygon(polygon, "%s_%d" % (base_id, i+1)) for i, polygon in enumerate(geom) ] elif geom.geom_typeid == 3: # Polygon polygons = [self.encode_polygon(geom, base_id)] return GML("MultiSurface", *[GML("surfaceMember", polygon) for polygon in polygons], **{ns_gml("id"): "multisurface_%s" % base_id, "srsName": "EPSG:4326" } )
def encode_dataset_series_description(self, dataset_series): elements = [] if dataset_series.footprint: elements.append(self.encode_bounded_by(dataset_series, None)) elements.append(EOWCS("DatasetSeriesId", dataset_series.identifier)) if dataset_series.begin_time and dataset_series.end_time: elements.append( self.encode_time_period( dataset_series.begin_time, dataset_series.end_time, "%s_timeperiod" % dataset_series.identifier)) return EOWCS( "DatasetSeriesDescription", *elements, **{ns_gml("id"): self.get_gml_id(dataset_series.identifier)})
def encode_coverage_description(self, coverage): if issubclass(coverage.real_type, ReferenceableDataset): rectified = False else: rectified = True return WCS( "CoverageDescription", self.encode_bounded_by(coverage.extent_wgs84), WCS("CoverageId", coverage.identifier), self.encode_domain_set(coverage, rectified=rectified), self.encode_range_type(self.get_range_type( coverage.range_type_id)), WCS("ServiceParameters", WCS("CoverageSubtype", coverage.real_type.__name__)), **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
def encode_referenceable_dataset(self, coverage, range_type, reference, mime_type, subset=None): # handle subset dst_srid = coverage.srid if not subset: # whole area - no subset domain_set = self.encode_domain_set(coverage, rectified=False) eo_metadata = self.encode_eo_metadata(coverage) extent = coverage.extent sr = SpatialReference(dst_srid) else: # subset is given srid, size, extent, footprint = subset srid = srid if srid is not None else 4326 domain_set = self.encode_domain_set( coverage, srid, size, extent, False ) eo_metadata = self.encode_eo_metadata( coverage, subset_polygon=footprint ) # get the WGS84 extent poly = Polygon.from_bbox(extent) poly.srid = srid if srid != dst_srid: poly.transform(dst_srid) extent = poly.extent sr = SpatialReference(srid) return EOWCS("ReferenceableDataset", self.encode_bounded_by(extent, sr), domain_set, self.encode_range_set(reference, mime_type), self.encode_range_type(range_type), eo_metadata, **{ ns_gml("id"): self.get_gml_id(coverage.identifier) } )
def encode_referenceable_dataset(self, coverage, range_type, reference, mime_type, subset=None): # handle subset dst_srid = SpatialReference( coverage.grid.coordinate_reference_system).srid if not subset: # whole area - no subset domain_set = self.encode_domain_set(coverage, rectified=False) eo_metadata = self.encode_eo_metadata(coverage) extent = coverage.footprint.extent sr = SpatialReference(dst_srid) else: # subset is given srid, size, extent, footprint = subset srid = srid if srid is not None else 4326 domain_set = self.encode_domain_set(coverage, srid, size, extent, False) eo_metadata = self.encode_eo_metadata(coverage, subset_polygon=footprint) # get the WGS84 extent poly = Polygon.from_bbox(extent) poly.srid = srid if srid != dst_srid: poly.transform(dst_srid) extent = poly.extent sr = SpatialReference(srid) return EOWCS("ReferenceableDataset", self.encode_bounded_by(coverage, coverage.grid, extent), domain_set, self.encode_range_set(reference, mime_type), self.encode_range_type(range_type), eo_metadata, **{ns_gml("id"): self.get_gml_id(coverage.identifier)})
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 encode_footprint(self, footprint, eo_id): return EOP("Footprint", EOP("multiExtentOf", self.encode_multi_surface(footprint, eo_id)), **{ns_gml("id"): "footprint_%s" % eo_id} )
def encode_time_instant(self, time, identifier): return GML("TimeInstant", GML("timePosition", isoformat(time)), **{ns_gml("id"): identifier} )
def encode_time_period(self, begin_time, end_time, identifier): return GML("TimePeriod", GML("beginPosition", isoformat(begin_time)), GML("endPosition", isoformat(end_time)), **{ns_gml("id"): identifier} )