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}
)
