def test_empty_mask(): from shapely import geometry polygon = geometry.Polygon([[1.0, 1.0], [2.0, 1.0], [2.0, 1.0], [1.0, 1.0]]) client = ImageCollectionClient(node_id=None, builder=GraphBuilder(), session=None) with pytest.raises(ValueError, match=r"Mask .+ has an area of 0.0"): client.mask(polygon)
def setUp(self): builder = GraphBuilder() id = builder.process("get_collection", {'name': 'S1'}) connection = MagicMock(spec=Connection) capabilities = MagicMock(spec=Capabilities) connection.capabilities.return_value = capabilities capabilities.version.return_value = "0.4.0" self.img = ImageCollectionClient(id, builder, connection) builder = GraphBuilder() mask_id = builder.process("get_collection", {'name': 'S1_Mask'}) self.mask = ImageCollectionClient(mask_id, builder, connection)
def test_metadata_load_collection_040(session040, requests_mock): requests_mock.get(API_URL + "/collections/SENTINEL2", json={ "properties": { "cube:dimensions": { "bands": { "type": "bands", "values": ["B2", "B3"] } }, "eo:bands": [ { "name": "B2", "common_name": "blue" }, { "name": "B3", "common_name": "green" }, ] } }) im = ImageCollectionClient.load_collection('SENTINEL2', session=session040) assert im.metadata.bands == [ openeo.metadata.Band("B2", "blue", None), openeo.metadata.Band("B3", "green", None) ]
def load_collection( self, collection_id: str, spatial_extent: Optional[Dict[str, float]] = None, temporal_extent: Optional[List[Union[str, datetime.datetime, datetime.date]]] = None, bands: Optional[List[str]] = None, properties: Optional[Dict[str, Union[str, PGNode, Callable]]] = None ) -> DataCube: """ Load a DataCube by collection id. :param collection_id: image collection identifier :param spatial_extent: limit data to specified bounding box or polygons :param temporal_extent: limit data to specified temporal interval :param bands: only add the specified bands :param properties: limit data by metadata property predicates :return: a datacube containing the requested data """ if self._api_version.at_least("1.0.0"): return DataCube.load_collection(collection_id=collection_id, connection=self, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands, properties=properties) else: return ImageCollectionClient.load_collection( collection_id=collection_id, session=self, spatial_extent=spatial_extent, temporal_extent=temporal_extent, bands=bands)
def image_collection(): builder = GraphBuilder() id = builder.process("get_collection", {'name': 'S1'}) connection = MagicMock(spec=Connection) capabilities = MagicMock(spec=Capabilities) connection.capabilities.return_value = capabilities capabilities.version.return_value = "0.4.0" return ImageCollectionClient(id, builder, connection)
def eodc_script(output_filename): """ """ backend_url = 'https://openeo.eodc.eu' session = openeo.connect(backend_url, auth_type='basic', auth_options={ "username": os.environ["EODC_USERNAME"], "password": os.environ["EODC_PASSWORD"] }) minx = 11.279182434082033 maxx = 11.406898498535158 maxy = 46.522729291844286 miny = 46.464349400461145 epsg = "EPSG:4326" spatial_extent = { 'west': minx, 'east': maxx, 'north': maxy, 'south': miny, 'crs': epsg } temporal_extent = ["2018-06-04T00:00:00.000Z", "2018-06-23T00:00:00.000Z"] spectral_extent = [8, 4, 2] s2a = ImageCollectionClient.load_collection( session=session, collection_id='s2a_prd_msil1c', temporal_extent=temporal_extent, spatial_extent=spatial_extent, bands=spectral_extent) s2b = s2a.load_collection(session=session, collection_id='s2b_prd_msil1c', temporal_extent=temporal_extent, spatial_extent=spatial_extent, bands=spectral_extent) s2_radiometry = s2a.merge(s2b) #s2_radiometry = B02 = s2_radiometry.band(2) B04 = s2_radiometry.band(1) B08 = s2_radiometry.band(0) evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 10000) min_evi = evi_cube.min_time() output = min_evi.download(output_filename, format="GTiff")
def load_collection(self, collection_id: str, **kwargs) -> ImageCollectionClient: """ Load an image collection by collection id see :py:meth:`openeo.rest.imagecollectionclient.ImageCollectionClient.load_collection` for available arguments. :param collection_id: image collection identifier (string) :return: ImageCollectionClient """ return ImageCollectionClient.load_collection( collection_id=collection_id, session=self, **kwargs)
def load_disk_collection(self, format: str, glob_pattern: str, options: dict = {}) -> ImageCollectionClient: """ Loads image data from disk as an ImageCollection. :param format: the file format, e.g. 'GTiff' :param glob_pattern: a glob pattern that matches the files to load from disk :param options: options specific to the file format :return: the data as an ImageCollection """ return ImageCollectionClient.load_disk_collection( self, format, glob_pattern, **options)
def load_collection(self, collection_id: str, **kwargs) -> Union[ImageCollectionClient, DataCube]: """ Load an image collection by collection id see :py:meth:`openeo.rest.imagecollectionclient.ImageCollectionClient.load_collection` for available arguments. :param collection_id: image collection identifier (string) :return: ImageCollectionClient """ if self._api_version.at_least("1.0.0"): return DataCube.load_collection(collection_id=collection_id, connection=self, **kwargs) else: return ImageCollectionClient.load_collection(collection_id=collection_id, session=self, **kwargs)
def load_disk_collection(self, format: str, glob_pattern: str, options: dict = {}) -> ImageCollectionClient: """ Loads image data from disk as an ImageCollection. :param format: the file format, e.g. 'GTiff' :param glob_pattern: a glob pattern that matches the files to load from disk :param options: options specific to the file format :return: the data as an ImageCollection """ if self._api_version.at_least("1.0.0"): return DataCube.load_disk_collection(self, format, glob_pattern, **options) else: return ImageCollectionClient.load_disk_collection(self, format, glob_pattern, **options)
def eurac_script(input_data, output_filename): """ """ backend_url = 'https://openeo.eurac.edu' if input_data == 'L1C': collection_id = 'openEO_S2_32632_10m_L1C_D22' elif input_data == 'L2A': collection_id = 'openEO_S2_32632_10m_L2A_D22' session = openeo.connect(backend_url, auth_type='basic', auth_options={ "username": os.environ["EURAC_USERNAME"], "password": os.environ["EURAC_PASSWORD"] }) minx = 11.279182434082033 maxx = 11.406898498535158 maxy = 46.522729291844286 miny = 46.464349400461145 epsg = "EPSG:4326" s2_radiometry = ImageCollectionClient.load_collection( session=session, collection_id=collection_id, temporal_extent=[ "2018-06-04T00:00:00.000Z", "2018-06-23T00:00:00.000Z" ], spatial_extent={ 'west': minx, 'east': maxx, 'north': maxy, 'south': miny, 'crs': epsg }, bands=["B08", "B04", "B02"]) B02 = s2_radiometry.band(2) B04 = s2_radiometry.band(1) B08 = s2_radiometry.band(0) evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 10000) min_evi = evi_cube.min_time() output = min_evi.download(output_filename, format="GTiff")
def vito_script(input_data, output_filename): """ """ backend_url = 'https://openeo.vito.be/openeo/0.4.2' if input_data == 'L1C': collection_id = 'SENTINEL2_L1C_SENTINELHUB' elif input_data == 'L2A': collection_id = 'SENTINEL2_L2A_SENTINELHUB' session = openeo.connect(backend_url) minx = 11.279182434082033 maxx = 11.406898498535158 maxy = 46.522729291844286 miny = 46.464349400461145 epsg = "EPSG:4326" spatial_extent = { 'west': minx, 'east': maxx, 'north': maxy, 'south': miny, 'crs': epsg } temporal_extent = ["2018-06-04T00:00:00.000Z", "2018-06-22T00:00:00.000Z"] spectral_extent = ["B08", "B04", "B02"] s2_radiometry = ImageCollectionClient.load_collection( session=session, collection_id=collection_id, temporal_extent=temporal_extent, spatial_extent=spatial_extent) B02 = s2_radiometry.band(spectral_extent[2]) B04 = s2_radiometry.band(spectral_extent[1]) B08 = s2_radiometry.band(spectral_extent[0]) evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 1.0) min_evi = evi_cube.min_time() output = min_evi.download(output_filename, format="GeoTiff")
def sinergise_script(output_filename): """ """ backend_url = 'https://e3oind87n9.execute-api.eu-central-1.amazonaws.com/production/' #'https://openeo.sentinel-hub.com/production' collection_id = 'S2L1C' session = openeo.connect(backend_url) minx = 11.279182434082033 maxx = 11.406898498535158 maxy = 46.522729291844286 miny = 46.464349400461145 epsg = "EPSG:4326" spatial_extent = { 'west': minx, 'east': maxx, 'north': maxy, 'south': miny, 'crs': epsg } temporal_extent = ["2018-06-04T00:00:00.000Z", "2018-06-23T00:00:00.000Z"] spectral_extent = ["B08", "B04", "B02"] s2_radiometry = ImageCollectionClient.load_collection( session=session, collection_id=collection_id, temporal_extent=temporal_extent, spatial_extent=spatial_extent) B02 = s2_radiometry.band(spectral_extent[2]) B04 = s2_radiometry.band(spectral_extent[1]) B08 = s2_radiometry.band(spectral_extent[0]) evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 1.0) min_evi = evi_cube.min_time() min_evi.download(output_filename, format="GTiff", options={"datatype": "float32"})
def mundialis_script(output_filename): """ """ backend_url = 'https://openeo.mundialis.de' collection_id = 'utm32n.openeo_bolzano.strds.openeo_bolzano_S2' session = openeo.connect(backend_url, auth_type='basic', auth_options={ "username": os.environ["MUNDIALIS_USERNAME"], "password": os.environ["MUNDIALIS_PASSWORD"] }) minx = 11.279182434082033 maxx = 11.406898498535158 maxy = 46.522729291844286 miny = 46.464349400461145 epsg = "EPSG:4326" s2_radiometry = ImageCollectionClient.load_collection( session=session, collection_id=collection_id, temporal_extent=[ "2018-06-04T00:00:00.000Z", "2018-06-23T00:00:00.000Z" ], spatial_extent={ 'west': minx, 'east': maxx, 'north': maxy, 'south': miny, 'crs': epsg }) B02 = s2_radiometry.band("S2_2") B04 = s2_radiometry.band("S2_4") B08 = s2_radiometry.band("S2_8") evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 10000) min_evi = evi_cube.min_time() output = min_evi.download(output_filename, format="GTiff")
class TestRasterCube(TestCase): def setUp(self): builder = GraphBuilder() id = builder.process("get_collection", {'name': 'S1'}) connection = MagicMock(spec=Connection) capabilities = MagicMock(spec=Capabilities) connection.capabilities.return_value = capabilities capabilities.version.return_value = "0.4.0" self.img = ImageCollectionClient(id, builder, connection) builder = GraphBuilder() mask_id = builder.process("get_collection", {'name': 'S1_Mask'}) self.mask = ImageCollectionClient(mask_id, builder, connection) def test_filter_bbox(self): im = self.img.filter_bbox( west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632" ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_filter_bbox_base_height(self): im = self.img.filter_bbox( west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632", base=100, height=200, ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632", "base": 100, "height": 200, } def test_bbox_filter_nsew(self): im = self.img.bbox_filter( west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632" ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_bbox_filter_tblr(self): im = self.img.bbox_filter( left=652000, right=672000, top=5161000, bottom=5181000, srs="EPSG:32632" ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_bbox_filter_nsew_zero(self): im = self.img.bbox_filter( west=0, east=0, north=0, south=0, crs="EPSG:32632" ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 0, "east": 0, "north": 0, "south": 0, "crs": "EPSG:32632" } def test_min_time(self): img = self.img.min_time() graph = img.graph[img.node_id] assert graph["process_id"] == "reduce" assert graph["arguments"]["data"] == {'from_node': 'getcollection1'} assert graph["arguments"]["dimension"] == "temporal" callback, = graph["arguments"]["reducer"]["callback"].values() assert callback == {'arguments': {'data': {'from_argument': 'data'}}, 'process_id': 'min', 'result': True} def test_max_time(self): img = self.img.max_time() graph = img.graph[img.node_id] assert graph["process_id"] == "reduce" assert graph["arguments"]["data"] == {'from_node': 'getcollection1'} assert graph["arguments"]["dimension"] == "temporal" callback, = graph["arguments"]["reducer"]["callback"].values() assert callback == {'arguments': {'data': {'from_argument': 'data'}}, 'process_id': 'max', 'result': True} def test_reduce_time_udf(self): img = self.img.reduce_tiles_over_time("my custom code") graph = img.graph[img.node_id] self.assertEqual(graph["process_id"], "reduce") self.assertIn("data", graph['arguments']) def test_ndvi(self): img = self.img.ndvi() graph = img.graph[img.node_id] assert graph["process_id"] == "ndvi" assert graph["arguments"] == { 'data': {'from_node': 'getcollection1'}, 'name': 'ndvi' } def test_mask(self): polygon = shapely.geometry.Polygon([[0, 0], [1.9, 0], [1.9, 1.9], [0, 1.9]]) img = self.img.mask(polygon) graph = img.graph[img.node_id] assert graph["process_id"] == "mask" assert graph["arguments"] == { "data": {'from_node': 'getcollection1'}, "mask": { 'coordinates': (((0.0, 0.0), (1.9, 0.0), (1.9, 1.9), (0.0, 1.9), (0.0, 0.0)),), 'crs': {'properties': {'name': 'EPSG:4326'}, 'type': 'name'}, 'type': 'Polygon' } } def test_mask_raster(self): img = self.img.mask(rastermask=self.mask, replacement=102) graph = img.graph[img.node_id] assert graph == { "process_id": "mask", "arguments": { "data": { "from_node": "getcollection1" }, "mask": { "from_node": "getcollection2" }, "replacement": 102 }, "result": False } def test_stretch_colors(self): img = self.img.stretch_colors(-1, 1) graph = img.graph[img.node_id] assert graph["process_id"] == "stretch_colors" assert graph["arguments"] == { 'data': {'from_node': 'getcollection1'}, 'max': 1, 'min': -1, } def test_apply_kernel(self): kernel = [[0, 1, 0], [1, 1, 1], [0, 1, 0]] img = self.img.apply_kernel(np.asarray(kernel), 3) graph = img.graph[img.node_id] assert graph["process_id"] == "apply_kernel" assert graph["arguments"] == { 'data': {'from_node': 'getcollection1'}, 'factor': 3, 'kernel': [[0, 1, 0], [1, 1, 1], [0, 1, 0]] } def test_resample_spatial(self): new_imagery = self.img.resample_spatial(resolution=[2.0,3.0],projection=4578) graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "resample_spatial") self.assertIn("data", graph["arguments"]) self.assertEqual(graph["arguments"]["resolution"], [2.0,3.0]) self.assertEqual(graph["arguments"]["projection"], 4578)
def test_filter_bands(image_collection: ImageCollectionClient): im = image_collection.filter_bands(["red", "nir"]) graph = im.graph[im.node_id] assert graph['process_id'] == 'filter_bands' assert graph['arguments']['bands'] == ["red", "nir"]
def test_filter_temporal_generic(image_collection: ImageCollectionClient, args, kwargs, extent): im = image_collection.filter_temporal(*args, **kwargs) graph = im.graph[im.node_id] assert graph['process_id'] == 'filter_temporal' assert graph['arguments']['extent'] == extent
def test_filter_temporal_extent(image_collection: ImageCollectionClient): im = image_collection.filter_temporal(extent=("2016-01-01", "2016-03-10")) graph = im.graph[im.node_id] assert graph['process_id'] == 'filter_temporal' assert graph['arguments']['extent'] == ["2016-01-01", "2016-03-10"]
maxx = 10.62927246093749 maxy = 46.84516443029275 miny = 46.72574176193996 epsg = "EPSG:4326" spatial_extent = {'west':minx,'east':maxx,'north':maxy,'south':miny,'crs':epsg} temporal_extent=["2018-05-01T00:00:00.000Z","2018-10-01T00:00:00.000Z"] # To find the band names in GRASS GIS: `g.bands pattern="S2"` spectral_extent = ["S2_8", "S2_4", "S2_2"] # connect to mundialis backend session = openeo.connect(backend_url).authenticate_basic(auth_id, password = auth_pwd) # TODO change to s2_radiometry = session.load_collection( ...) s2_radiometry = ImageCollectionClient.load_collection( session=session, collection_id=collection_id, temporal_extent=temporal_extent, spatial_extent=spatial_extent ) # g.bands pattern="S2" B02 = s2_radiometry.band("S2_2") B04 = s2_radiometry.band("S2_4") B08 = s2_radiometry.band("S2_8") evi_cube = (2.5 * (B08 - B04)) / ((B08 + 6.0 * B04 - 7.5 * B02) + 10000) min_evi = evi_cube.min_time() output = min_evi.download_results("min-evi_mundialis.tiff",format="GTiff")
class TestRasterCube(TestCase): @patch.multiple(Connection, __abstractmethods__=set()) def setUp(self): builder = GraphBuilder() id = builder.process("get_collection", {'name': 'S1'}) connection = MagicMock(spec=Connection) capabilities = MagicMock(spec=Capabilities) connection.capabilities.return_value = capabilities capabilities.version.return_value = "0.4.0" self.imagery = ImageCollectionClient(id, builder, connection) builder = GraphBuilder() mask_id = builder.process("get_collection", {'name': 'S1_Mask'}) self.mask = ImageCollectionClient(mask_id, builder, connection) def test_filter_bbox(self): im = self.imagery.filter_bbox(west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632") graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_filter_bbox_base_height(self): im = self.imagery.filter_bbox( west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632", base=100, height=200, ) graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632", "base": 100, "height": 200, } def test_bbox_filter_nsew(self): im = self.imagery.bbox_filter(west=652000, east=672000, north=5161000, south=5181000, crs="EPSG:32632") graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_bbox_filter_tblr(self): im = self.imagery.bbox_filter(left=652000, right=672000, top=5161000, bottom=5181000, srs="EPSG:32632") graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 652000, "east": 672000, "north": 5161000, "south": 5181000, "crs": "EPSG:32632" } def test_bbox_filter_nsew_zero(self): im = self.imagery.bbox_filter(west=0, east=0, north=0, south=0, crs="EPSG:32632") graph = im.graph[im.node_id] assert graph["process_id"] == "filter_bbox" assert graph["arguments"]["extent"] == { "west": 0, "east": 0, "north": 0, "south": 0, "crs": "EPSG:32632" } def test_min_time(self): new_imagery = self.imagery.min_time() graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "reduce") self.assertIn("data", graph['arguments']) def test_max_time(self): new_imagery = self.imagery.max_time() graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "reduce") self.assertIn("data", graph['arguments']) def test_reduce_time_udf(self): new_imagery = self.imagery.reduce_tiles_over_time("my custom code") graph = new_imagery.graph[new_imagery.node_id] import json print(json.dumps(graph, indent=2)) self.assertEqual(graph["process_id"], "reduce") self.assertIn("data", graph['arguments']) def test_ndvi(self): new_imagery = self.imagery.ndvi("B04", "B8A") graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "ndvi") self.assertIn("data", graph['arguments']) def test_mask(self): from shapely import geometry polygon = geometry.Polygon([[0, 0], [1.9, 0], [1.9, 1.9], [0, 1.9]]) new_imagery = self.imagery.mask(polygon) graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "mask") self.assertEqual( graph["arguments"]["mask"], { 'coordinates': (((0.0, 0.0), (1.9, 0.0), (1.9, 1.9), (0.0, 1.9), (0.0, 0.0)), ), 'crs': { 'properties': { 'name': 'EPSG:4326' }, 'type': 'name' }, 'type': 'Polygon' }) def test_mask_raster(self): new_imagery = self.imagery.mask(rastermask=self.mask, replacement=102) graph = new_imagery.graph[new_imagery.node_id] import json print(json.dumps(new_imagery.graph, indent=4)) expected_mask_node = { "process_id": "mask", "arguments": { "data": { "from_node": "getcollection1" }, "mask": { "from_node": "getcollection2" }, "replacement": 102 }, "result": False } self.assertDictEqual(expected_mask_node, graph) def test_strech_colors(self): new_imagery = self.imagery.stretch_colors(-1, 1) graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "stretch_colors") self.assertIn("data", graph['arguments']) self.assertEqual(graph["arguments"]["min"], -1) self.assertEqual(graph["arguments"]["max"], 1) def test_apply_kernel(self): kernel = [[0, 1, 0], [1, 1, 1], [0, 1, 0]] new_imagery = self.imagery.apply_kernel(np.asarray(kernel), 3) graph = new_imagery.graph[new_imagery.node_id] self.assertEqual(graph["process_id"], "apply_kernel") self.assertIn("data", graph["arguments"]) self.assertEqual(graph["arguments"]["factor"], 3) self.assertEqual(graph["arguments"]["kernel"], kernel)
def execute( out_dir, user, password, provider, driver_url, image_collection, all_bands, bands, band_format, bbox_string, temporal_extent, ): """ Identification: Name -- OpenEO PoC Description -- Retrieve Sentinel 2 bands in GeoTIFF Version -- 1-hbo Author -- Alexander Jacob, Eurac Research, openEO Mission -- hackathon Inputs: user -- User -- 45/User String -- openeo password -- Password -- 45/User String -- XXXXXXXXX provider -- Provider -- 45/User String -- mundialis driver_url -- Driver URL -- 45/User String -- https://openeo.mundialis.de image_collection -- Image Collection -- 45/User String -- utm32n.openeo_bolzano.strds.openeo_bolzano_S2 all_bands -- Bands -- 45/User String -- B02 B03 B04 B05 B06 B07 B8A B11 B12 bands -- Bands -- 45/User String -- B03 B11 band_format -- Band Format -- 45/User String -- GTiff bbox_string -- BBox -- 45/User String -- 10.446624755859375, 46.72574176193996, 10.629272460937498, 46.845164430292755 temporal_extent -- Temporal Extent -- 44/DateRange -- 2018-05-01T00:00:00.000Z/2018-10-01T00:00:00.000Z Outputs: band_dir -- Band Directory -- 45/User String band_files -- Band Files -- 45/User String out_dir -- directory to store output Main Dependency: python-3 Software Dependencies: openeo-0.4 Processing Resources: ram -- 1 disk -- 10 cpu -- 1 """ all_bands = all_bands.split() bands = bands.split() temporal_extent = temporal_extent.split("/") west, south, east, north = list( map(lambda value: value.strip(), bbox_string.split(","))) bbox = {"west": west, "east": east, "south": south, "north": north} logger.info("Demo user: %s", user) logger.info("Provider: %s with driver URL %s", provider, driver_url) logger.info("Image Collection: %s", image_collection) logger.info("Bands: %s", bands) logger.info( "Using BBox in str format - raw input (west, south, east, north): %s", bbox_string) logger.info("BBox: %s", bbox) logger.info("Temporal extent in string format start/end: %s", temporal_extent) connection = openeo.connect(driver_url) connection.authenticate_basic(user, password) logger.info( "describe_collection('%s'):\n %s\n", image_collection, json.dumps(connection.describe_collection(image_collection), indent=2), ) # TODO: change to con.load_collection() cube = ImageCollectionClient.load_collection( session=connection, collection_id=image_collection, bands=all_bands) cube = cube.filter_bbox(**bbox) cube = cube.filter_temporal(extent=temporal_extent) logger.info("cube.to_json: \n%s\n", cube.to_json()) logger.info("File Format: %s", band_format) logger.info( "File Name Format: {provider}.{image_collection}.{west}.{south}.{east}.{north}." "{temporal_extent[0]}.{temporal_extent[1]}.B{band.zfill(2)}.{band_format}" ) band_dir = out_dir logger.info("Downloading bands in %s", out_dir) band_files = [] for band in bands: cube_band = cube.band(band) band_file = ( f"{provider}.{image_collection}.{west}.{south}.{east}.{north}." f"{temporal_extent[0]}.{temporal_extent[1]}.B{band.zfill(2)}.{band_format.lower()}" ) logger.info("Downloading band %s: %s", band, band_file) band_path = f"{out_dir}/{band_file}" band_files.append(band_file) logger.info("Starting download at %s", datetime.now()) cube_band.download(band_path, format=band_format) logger.info("Download finished for band %s at %s", band, datetime.now()) logger.info("Downloads finished at %s", datetime.now()) return {"band_dir": band_dir, "band_files": band_files}