Initial version.

LICENCE

+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

+# GTS2 Sentinel-2 downloader
+## Requirements
+#### Python packages:
+* numpy
+* gdal
+* osr
+* scipy
+* json
+
+## Installation
+<code> python gts2-client/setup.py install </code>
+
+## Usage
+<code>gts2_api_interface.py [-h] -o OUT_DIR -op OUT_PREFIX [-om OUT_MODE]
+                             -lla LAT_LL -llo LON_LL -ura LAT_UR -uro LON_UR
+                             [-s SENSOR] [-l LEVEL] [-v VERSION] -b BANDS -sd
+                             START_DATE -ed END_DATE [-c COREG]
+                             [-mc MAX_CLOUDY] [-mf MINIMUM_FILL] -un USERNAME
+                             -pw PASSWORD </code>
+
+Arguments:
+  * -h, --help            show this help message and exit
+  * -o OUT_DIR, --out_dir OUT_DIR
+    output_directory
+  * -op OUT_PREFIX, --out_prefix OUT_PREFIX
+    output_prefix for naming the output files
+  * -om OUT_MODE, --out_mode OUT_MODE
+    output_mode, use 'json' for json-file,'single' for
+    single tiffs or 'stack' for band stack
+  * -lla LAT_LL, --lat_ll LAT_LL
+    latitude lower left corner
+  * -llo LON_LL, --lon_ll LON_LL
+    longitude lower left corner
+  * -ura LAT_UR, --lat_ur LAT_UR
+    latitude upper right corner
+  * -uro LON_UR, --lon_ur LON_UR
+     longitude upper right corner
+  * -s SENSOR, --sensor SENSOR
+     sensor name
+  * -l LEVEL, --level LEVEL
+     processing level
+  * -v VERSION, --version VERSION
+     version of atmospheric correction
+  * -b BANDS, --bands BANDS
+     list of Bands (e.g. -b B02_B03)
+  * -sd START_DATE, --start_date START_DATE
+     Startdate e.g. 20160701
+  * -ed END_DATE, --end_date END_DATE
+     Enddate e.g. 20160701
+  * -c COREG, --coreg COREG
+     get data with corrected pixel shifts
+  * -mc MAX_CLOUDY, --max_cloudy MAX_CLOUDY
+     maximal percentage of cloudyness of scene
+  * -mf MINIMUM_FILL, --minimum_fill MINIMUM_FILL
+     minimal percentage of data in scene
+  * -un USERNAME, --username USERNAME
+     Username
+  * -pw PASSWORD, --password PASSWORD
+     Password

gts2_client/__init__.py

+#import .gts2_api_interfaces
\ No newline at end of file

gts2_client/gts2_client.py

+#!/usr/bin/env python
+
+import logging
+import requests
+import numpy as np
+import warnings
+import gdal
+import osr
+import argparse
+from scipy.ndimage.interpolation import zoom
+import json
+
+warnings.filterwarnings("ignore")
+
+
+class gts2_request(dict):
+    def __init__(self, ll, ur, auth, adress="https://rz-vm175.gfz-potsdam.de:80/AC", bands="B02_B04_B08", version="0.6",
+                 date_from="20160107", date_to="20160507", minimum_fill=1.0, sensor="S2A", level="L2A", suffix="",
+                 logger=None, max_cloudy=1.0):
+
+        # test parameters such that api string formating wont fail
+        assert len(ur) == 2
+        assert len(ll) == 2
+        assert sensor in ["S2A", "S2all"]
+        assert level in ["L1C", "L2A"]
+        assert type(version) is str  # e.g. 0.6
+        assert type(suffix) is str
+        # assert type(max_cloudy) is str
+
+        # get logger
+        self.logger = logger or logging.getLogger(__name__)
+        # define api pattern
+        self.api_fmt = "".join([
+            "{adress}/{bands}/{date_from}_{date_to}/{ll_lon:.5f}_{ur_lon:.5f}_{ll_lat:.5f}_{ur_lat:.5f}",
+            "?minimum_fill={minimum_fill:.1f}&sensor={sensor}&level={level}&version={version}&suffix={suffix}&max_cloudy={max_cloudy:.1f}"
+        ])
+        # construct api call
+        self.api_call = self.api_fmt.format(adress=adress, bands=bands, date_from=date_from, date_to=date_to,
+                                            suffix=suffix,
+                                            minimum_fill=minimum_fill, sensor=sensor, level=level, version=version,
+                                            ll_lon=ll[0], ll_lat=ll[1],
+                                            ur_lon=ur[0], ur_lat=ur[1], max_cloudy=max_cloudy)
+        print("API-call: %s " % self.api_call)
+        # get data, update dict from json
+        self.update(requests.get(self.api_call, verify=False, auth=auth).json())
+
+    def pp(self):
+        """ Pretty printing of self contents."""
+        self._pp(self)
+
+    def _pp(self, dd, l=0, lmax=10, of="  "):
+        """
+        Recursive pretty printing helper
+        :param dd: dictionary for pretty printing
+        :param l: Recursion parameter, increase when going down recursion.
+        :param of: White space separator for pretty printing.
+        """
+        for key, value in dd.items():
+            # self.logger.info(l*of + key + " -> " + str(type(value)))
+            # self.logger.info(str(type(value)))
+            if str(type(value)) == "<class 'list'>":
+                self.logger.info(l * of + key + " -> " + str(type(value)) + str(np.shape(np.array(value))))
+            else:
+                self.logger.info(l * of + key + " -> " + str(type(value)))
+
+            if type(value) is dict:
+                self._pp(value, l=l + 1)
+                if l > lmax:
+                    raise
+
+
+def api_to_tiff(outpath="", out_prefix="", out_mode="json", geo_ll=(), geo_ur=(), sensor="", bands="", max_cloudy=0.0,
+                level="", start_date="", end_date="", version=0.9, suffix="", minimum_fill=0.0, auth=("", "")):
+    """
+    Downloads data via API and converts it to geotiff file
+    :param minimum_fill:
+    :param outpath: string
+    :param out_prefix: string
+    :param out_mode: string
+    :param geo_ll: tuple of floats
+    :param geo_ur: tuple of floats
+    :param sensor: string
+    :param bands: string
+    :param max_cloudy: float
+    :param level: string
+    :param start_date: string
+    :param end_date: string
+    :param version: string
+    :param suffix: string
+    :return:
+    """
+
+    # options
+    opts = {"ll": geo_ll, "ur": geo_ur, "sensor": sensor, "bands": bands,
+            "max_cloudy": max_cloudy, "auth": auth, "level": level, "date_from": start_date, "date_to": end_date,
+            "version": str(version), "suffix": suffix, "minimum_fill": minimum_fill}
+
+    # actual request
+    rr_or = gts2_request(**opts)
+
+    if out_mode == "json":
+        json_outfile = "%s/%s_%s_%s_%s_%s_%s.json" % (outpath, out_prefix, geo_ll, geo_ur, start_date, end_date, bands)
+        with open(json_outfile, 'w') as f:
+            json.dump(rr_or, f)
+
+    # test parameters
+    try:
+        assert out_mode in ["json", "single", "stack"]
+    except:
+        raise AssertionError("Invalid output mode. Choose 'json', 'single' or 'stack'.")
+
+    # return numpy arrays and save each band as tiff file
+    tiles = []
+
+    if "message" in rr_or.keys():
+        print("API call not right or server Problem.")
+        print(rr_or["message"])
+        return None, None
+    if rr_or["ControlValues"]["API_status"] == 1:
+        print("API call not right or server Problem.")
+        print(rr_or["ControlValues"]["API_message"])
+        return None, None
+
+    epsg = 32633
+    for tile_key in rr_or['Results'].keys():
+        bands_res = []
+        for bi in range(len(rr_or['Request']['bands'])):
+            band = rr_or['Request']['bands'][bi]
+            res = rr_or['Request']['resolution'][bi]
+            dates = []
+            band_key = "%s_%sm" % (band, res)
+            for ti in range(len(rr_or['Results'][tile_key][band_key]['data'])):
+                data = rr_or['Results'][tile_key][band_key]['data'][ti]
+                ac_date = rr_or['Results'][tile_key][band_key]['time'][ti][:10]
+                x_min = rr_or['Results'][tile_key][band_key]['mapinfo']['utm_coord_ll_x']
+                y_max = rr_or['Results'][tile_key][band_key]['mapinfo']['utm_coord_ll_y']
+                arr = np.asarray(data)
+
+                clm = rr_or['Metadata'][tile_key]['MSK_' + str(res) + 'm']['data'][ti]
+                clm_arr = np.asarray(clm)
+
+                if out_mode == "single":
+                    rows, cols = arr.shape
+                    geotrans = (x_min, res, 0, y_max, 0, -res)
+
+                    driver = gdal.GetDriverByName("GTiff")
+                    outfile = "%s/%s_%s_%s_%s.tif" % (outpath, out_prefix, ac_date, tile_key, band)
+                    img = driver.Create(outfile, cols, rows, 1, gdal.GDT_Int32)
+                    img.SetGeoTransform(geotrans)
+                    srs = osr.SpatialReference()
+                    srs.ImportFromEPSG(epsg)
+                    img.SetProjection(srs.ExportToWkt())
+                    img.GetRasterBand(1).WriteArray(arr)
+                    img.FlushCache()
+                    img = None
+
+                    clm_outfile = "%s/%s_%s_%s_MSK_%sm.tif" % (outpath, out_prefix, ac_date, tile_key, res)
+                    img = driver.Create(clm_outfile, cols, rows, 1, gdal.GDT_Int32)
+                    img.SetGeoTransform(geotrans)
+                    srs = osr.SpatialReference()
+                    srs.ImportFromEPSG(epsg)
+                    img.SetProjection(srs.ExportToWkt())
+                    img.GetRasterBand(1).WriteArray(clm_arr)
+                    img.FlushCache()
+                    img = None
+
+                dates.append(arr)
+                dates.append(clm_arr)
+            bands_res.append(dates)
+        tiles.append(bands_res)
+
+    if out_mode == "stack":
+        for tile_key in rr_or['Results'].keys():
+            for ti in range(0, len(tiles[0][0]), 2):
+                zm_bands = []
+                for bi in range(1, len(tiles[0])):
+                    zoom_factor = np.array(tiles[0][0][ti].shape) / np.array(tiles[0][bi][ti].shape)
+                    zm = np.nan_to_num(np.array(tiles[0][bi][ti], dtype=np.float32))
+                    if (zoom_factor != [1.0, 1.0]).all():
+                        zm = zoom(input=zm, zoom=zoom_factor, order=1)
+                    zm_bands.append(zm)
+
+                rows, cols = tiles[0][0][ti].shape
+                band = rr_or['Request']['bands'][0]
+                res = rr_or['Request']['resolution'][0]
+                band_key = "%s_%sm" % (band, res)
+                ac_date = rr_or['Results'][tile_key][band_key]['time'][int(ti / 2)][:10]
+                x_min = rr_or['Results'][tile_key][band_key]['mapinfo']['utm_coord_ll_x']
+                y_max = rr_or['Results'][tile_key][band_key]['mapinfo']['utm_coord_ll_y']
+                geotrans = (x_min, res, 0, y_max, 0, -res)
+                driver = gdal.GetDriverByName("GTiff")
+                outfile = "%s/%s_%s_%s_stack_%s.tif" % (outpath, out_prefix, ac_date, tile_key, bands)
+                img = driver.Create(outfile, cols, rows, len(tiles[0]) + 1, gdal.GDT_Int32)
+                img.SetGeoTransform(geotrans)
+                srs = osr.SpatialReference()
+                srs.ImportFromEPSG(epsg)
+                img.SetProjection(srs.ExportToWkt())
+                img.GetRasterBand(1).WriteArray(tiles[0][0][ti])
+                for zi in range(0, len(zm_bands)):
+                    img.GetRasterBand(zi + 2).WriteArray(zm_bands[zi])
+                img.GetRasterBand(len(zm_bands) + 2).WriteArray(tiles[0][0][ti + 1])
+                img.FlushCache()
+                img = None
+
+    return rr_or, tiles
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-o", "--out_dir", action="store", required=True, type=str,
+                        help="output_directory")
+    parser.add_argument("-op", "--out_prefix", action="store", required=True, type=str,
+                        help="output_prefix for naming the output files")
+    parser.add_argument("-om", "--out_mode", action="store", required=False, type=str, default="json",
+                        help="output_mode, use 'json' for json-file,"
+                             "'single' for single tiffs or 'stack' for band stack")
+    parser.add_argument("-lla", "--lat_ll", action="store", required=True, type=float,
+                        help="latitude lower left corner")
+    parser.add_argument("-llo", "--lon_ll", action="store", required=True, type=float,
+                        help="longitude lower left corner")
+    parser.add_argument("-ura", "--lat_ur", action="store", required=True, type=float,
+                        help="latitude upper right corner")
+    parser.add_argument("-uro", "--lon_ur", action="store", required=True, type=float,
+                        help="longitude upper right corner")
+    parser.add_argument("-s", "--sensor", action="store", required=False, type=str, default="S2A",
+                        help="sensor name")
+    parser.add_argument("-l", "--level", action="store", required=False, type=str, default="L2A",
+                        help="processing level")
+    parser.add_argument("-v", "--version", action="store", required=False, type=float, default=0.9,
+                        help="version of atmospheric correction")
+    parser.add_argument("-b", "--bands", action="store", required=True, type=str,
+                        help="list of Bands (e.g. -b B02_B03")
+    parser.add_argument("-sd", "--start_date", action="store", required=True, type=str,
+                        help="Startdate e.g. 20160701")
+    parser.add_argument("-ed", "--end_date", action="store", required=True, type=str,
+                        help="Enddate e.g. 20160701")
+    parser.add_argument("-c", "--coreg", action="store", required=False, type=bool, default=True,
+                        help="get data with corrected pixel shifts")
+    parser.add_argument("-mc", "--max_cloudy", action="store", required=False, type=float, default=0.0,
+                        help="maximal percentage of cloudyness of scene")
+    parser.add_argument("-mf", "--minimum_fill", action="store", required=False, type=float, default=1.0,
+                        help="minimal percentage of data in scene")
+    parser.add_argument("-un", "--username", action="store", required=True, type=str,
+                        help="Username")
+    parser.add_argument("-pw", "--password", action="store", required=True, type=str,
+                        help="Password")
+
+    args = parser.parse_args()
+
+    suffix = "coreg" if (args.coreg is True) else ""
+
+    tile_dict, tiles = api_to_tiff(outpath=args.out_dir,
+                                   out_prefix=args.out_prefix,
+                                   out_mode=args.out_mode,
+                                   geo_ll=(args.lon_ll, args.lat_ll),
+                                   geo_ur=(args.lon_ur, args.lat_ur),
+                                   sensor=args.sensor,
+                                   level=args.level,
+                                   version=args.version,
+                                   bands=args.bands,
+                                   max_cloudy=args.max_cloudy,
+                                   suffix=suffix,
+                                   start_date=args.start_date,
+                                   end_date=args.end_date,
+                                   auth=(args.username, args.password))

setup.py

+from setuptools import setup
+
+setup(name='gt2_api_interface',
+      version='0.1',
+      packages=['gts2_client'],
+      url='',
+      license='GNU LESSER GENERAL PUBLIC LICENSE - Version 3, 29 June 2007',
+      author='Hannes Diedrich, Niklas Bohn, André Hollstein',
+      author_email='hannes.diedrich@gfz-potsdam.de',
+      description='Downloads Sentinel-2 data from GTS2 cloud',
+      scripts=['gts2_client/gts2_client.py'])
\ No newline at end of file