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)