def from_model(cls, product_model, browse_model):
filename = get_vsi_path(browse_model)
env = get_vsi_env(browse_model.storage)
size = (browse_model.width, browse_model.height)
extent = (
browse_model.min_x, browse_model.min_y,
browse_model.max_x, browse_model.max_y
)
ds = gdal_open(browse_model)
mode = _get_ds_mode(ds)
ds = None
if browse_model.browse_type:
name = '%s__%s' % (
product_model.identifier, browse_model.browse_type.name
)
else:
name = product_model.identifier
return cls(
name, filename, env, size, extent,
browse_model.coordinate_reference_system, mode,
product_model.footprint
)
def from_model(cls, model):
# use coverages EO metadata by default and fill up with
# EO metadata from Product
begin_time = model.begin_time
if not begin_time and model.parent_product:
begin_time = model.parent_product.begin_time
end_time = model.end_time
if not end_time and model.parent_product:
end_time = model.parent_product.end_time
footprint = model.footprint
if not footprint and model.parent_product:
footprint = model.parent_product.footprint
eo_metadata = EOMetadata(begin_time, end_time, footprint)
arraydata_locations = [
ArraydataLocation(get_vsi_path(item), get_vsi_env(item.storage),
item.format, item.field_index,
item.field_index + (item.band_count - 1))
for item in model.arraydata_items.all()
]
metadata_locations = [
Location(get_vsi_path(item), get_vsi_env(item.storage),
item.format) for item in model.metadata_items.all()
]
if model.coverage_type:
range_type = RangeType.from_coverage_type(model.coverage_type)
else:
range_type = RangeType.from_gdal_dataset(
gdal.OpenShared(arraydata_locations[0].path), model.identifier)
grid = Grid.from_model(model.grid)
origin = Origin.from_description(grid.types, model.origin)
return cls(identifier=model.identifier,
eo_metadata=eo_metadata,
range_type=range_type,
origin=origin,
grid=grid,
size=model.size,
arraydata_locations=arraydata_locations,
metadata_locations=metadata_locations)
def connect(self, coverage, data_items, layer, options):
mask_item = data_items[0]
try:
is_reversed = (
layer.metadata.get("eoxs_geometry_reversed") == "true")
except ms.MapServerError:
is_reversed = False
# check if the geometry is "reversed"
if is_reversed:
# TODO: better use the coverages Extent?
geom_types = (ogr.wkbPolygon, ogr.wkbMultiPolygon)
output_polygon = ogr.Geometry(wkt=str(coverage.footprint.wkt))
for mask_item in data_items:
ds = ogr.Open(get_vsi_path(mask_item))
for i in range(ds.GetLayerCount()):
ogr_layer = ds.GetLayer(i)
if not ogr_layer:
continue
feature = ogr_layer.GetNextFeature()
while feature:
# TODO: reproject if necessary
geometry = feature.GetGeometryRef()
if geometry.GetGeometryType() not in geom_types:
continue
if geometry:
output_polygon = output_polygon.Difference(
geometry)
feature = ogr_layer.GetNextFeature()
# since we have the geometry already in memory, add it to the layer
# as WKT
shape = ms.shapeObj.fromWKT(output_polygon.ExportToWkt())
shape.initValues(1)
shape.setValue(0, coverage.identifier)
layer.addFeature(shape)
else:
layer.connectiontype = ms.MS_OGR
layer.connection = connect(data_items[0])
# TODO: more than one mask_item?
layer.setProjection("EPSG:4326")
layer.setMetaData("ows_srs", "EPSG:4326")
layer.setMetaData("wms_srs", "EPSG:4326")
def from_model(cls, mask_model, mask_type):
filename = None
if mask_model and mask_model.location:
filename = get_vsi_path(mask_model)
geometry = None
if mask_model:
geometry = mask_model.geometry
mask_type = mask_type or mask_model.mask_type
validity = False
if mask_type:
validity = mask_type.validity
return cls(filename, geometry, validity)
def connect(self, coverage, data_items, layer, options):
layer.tileindex = get_vsi_path(data_items[0])
layer.tileitem = "location"
def register(self,
metadata_locations,
mask_locations,
package_path,
overrides,
identifier_template=None,
type_name=None,
extended_metadata=True,
discover_masks=True,
discover_browses=True,
discover_metadata=True,
replace=False,
simplify_footprint_tolerance=None):
product_type = None
if type_name:
product_type = models.ProductType.objects.get(name=type_name)
component = ProductMetadataComponent()
browse_handles = []
mask_locations = mask_locations or []
metadata = {}
package = None
if package_path:
handler = get_handler_by_test(package_path)
if not handler:
raise RegistrationError('Storage %r is not supported' %
package_path)
package, _ = backends.Storage.objects.get_or_create(
url=package_path, storage_type=handler.name)
if discover_masks or discover_browses or discover_metadata:
collected_metadata = component.collect_package_metadata(
package, handler)
if discover_metadata:
metadata.update(collected_metadata)
if discover_browses:
browse_handles.extend([
(browse_type, package_path, browse_path)
for browse_type, browse_path in metadata.pop(
'browses', [])
])
if discover_masks:
mask_locations.extend([(mask_type, package_path, mask_path)
for mask_type, mask_path in
metadata.pop('mask_files', [])])
mask_locations.extend([
(mask_type, geometry)
for mask_type, geometry in metadata.pop('masks', [])
])
metadata_items = [
models.MetaDataItem(location=location[-1],
storage=resolve_storage(location[:-1]))
for location in metadata_locations
]
new_metadata = {}
for metadata_item in reversed(metadata_items):
new_metadata.update(
self._read_product_metadata(component, metadata_item))
mask_locations.extend(new_metadata.pop('masks', []))
metadata.update(new_metadata)
metadata.update(
dict((key, value) for key, value in overrides.items()
if value is not None))
# apply overrides
identifier = metadata.get('identifier')
footprint = metadata.get('footprint')
begin_time = metadata.get('begin_time')
end_time = metadata.get('end_time')
if identifier_template:
identifier = identifier_template.format(metadata)
metadata['identifier'] = identifier
if simplify_footprint_tolerance is not None and footprint:
footprint = footprint.simplify(simplify_footprint_tolerance,
preserve_topology=True)
replaced = False
if replace:
try:
models.Product.objects.get(identifier=identifier).delete()
replaced = True
except models.Product.DoesNotExist:
pass
product = models.Product.objects.create(
identifier=identifier,
footprint=footprint,
begin_time=begin_time,
end_time=end_time,
product_type=product_type,
package=package,
)
if extended_metadata and metadata:
create_metadata(product, metadata)
# register all masks
for mask_handle in mask_locations:
geometry = None
storage = None
location = ''
if isinstance(mask_handle[1], GEOSGeometry):
geometry = GEOSGeometry(mask_handle[1])
else:
storage = resolve_storage(mask_handle[1:-1])
location = mask_handle[-1]
try:
mask_type = models.MaskType.objects.get(
name=mask_handle[0], product_type=product_type)
except models.MaskType.DoesNotExist:
raise
models.Mask.objects.create(product=product,
mask_type=mask_type,
storage=storage,
location=location,
geometry=geometry)
# register all browses
for browse_handle in browse_handles:
browse_type = None
if browse_handle[0]:
# TODO: only browse types for that product type
browse_type = models.BrowseType.objects.get(
name=browse_handle[0], product_type=product_type)
browse = models.Browse(product=product,
location=browse_handle[-1],
storage=resolve_storage(
browse_handle[1:-1]))
# Get a VSI handle for the browse to get the size, extent and CRS
# via GDAL
vsi_path = get_vsi_path(browse)
ds = gdal.Open(vsi_path)
browse.width = ds.RasterXSize
browse.height = ds.RasterYSize
browse.coordinate_reference_system = ds.GetProjection()
extent = gdal.get_extent(ds)
browse.min_x, browse.min_y, browse.max_x, browse.max_y = extent
browse.full_clean()
browse.save()
for metadata_item in metadata_items:
metadata_item.eo_object = product
metadata_item.full_clean()
metadata_item.save()
return product, replaced
def _read_product_metadata(self, component, metadata_item):
path = get_vsi_path(metadata_item)
with gdal.config_env(get_vsi_env(metadata_item.storage)):
return component.read_product_metadata_file(path)