def encode(cls, value):
""" Encode value to a Unicode string."""
if value == 0:
return u'ImageCRS'
elif validateEPSGCode(value):
return unicode(asURL(value))
raise ValueError("Invalid CRS %r!" % value)
def encode(cls, value):
""" Encode value to a unicode string."""
if value == 0:
return u'ImageCRS'
elif validateEPSGCode(value):
return unicode(asURL(value))
raise ValueError("Invalid CRS %r!" % value)
def parse(cls, raw_value):
""" Cast or parse input to its proper represenation."""
if isinstance(raw_value, cls.dtype):
if raw_value == 0 or validateEPSGCode(raw_value):
return raw_value
else:
if raw_value == "ImageCRS":
return 0
else:
value = parseEPSGCode(raw_value, (fromURL, fromURN, fromShortCode))
if value is not None:
return value
raise ValueError("Invalid CRS %r!" % raw_value)
def parse(cls, raw_value):
""" Cast or parse input to its proper representation."""
if isinstance(raw_value, cls.dtype):
if raw_value == 0 or validateEPSGCode(raw_value):
return raw_value
else:
if raw_value == "ImageCRS":
return 0
else:
value = parseEPSGCode(raw_value,
(fromURL, fromURN, fromShortCode))
if value is not None:
return value
raise ValueError("Invalid CRS %r!" % raw_value)
def readFromDataset(cls, ds, default_srid=None):
"""
This class method returns a :class:`GeospatialMetadata` object
initialized with the metadata read from the GDAL dataset ``ds``. It
expects an open :class:`osgeo.gdal.Dataset` object as input. Furthermore
it accepts an optional integer ``default_srid`` parameter that will be
used to set the SRID if it cannot be retrieved from the dataset.
"""
size_x = ds.RasterXSize
size_y = ds.RasterYSize
is_ref = ds.GetGCPCount() > 0
proj = ds.GetGCPProjection() if is_ref else ds.GetProjection()
if not isinstance(proj,basestring) or len(proj)<1 :
raise RuntimeError("Failed to extract CRS (projection) of the "
"dataset!" )
# convert projection to EPSG code
srs = osr.SpatialReference()
try:
srs.ImportFromWkt( proj )
srs.AutoIdentifyEPSG()
ptype = "PROJCS" if srs.IsProjected() else "GEOGCS"
srid = int(srs.GetAuthorityCode(ptype))
except (RuntimeError, TypeError), e:
logger.warn("Projection: %s" % proj)
logger.warn("Failed to identify projection's EPSG code."
"%s: %s" % ( type(e).__name__ , str(e) ) )
if default_srid is not None:
logger.warn("Using the provided SRID '%s' instead."
% str(default_srid) )
else:
raise RuntimeError("Unknown SRS and no default supplied.")
#validate the default SRID
if not crss.validateEPSGCode( default_srid ) :
raise RuntimeError("The default SRID '%s' is not a valid"
" EPSG code." % str(default_srid) )
srid = int(default_srid)
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
