s3-olci-tiling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Sentinel-3 OLCI Level-2 Tiling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Service Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "service = dict([('title', 'Sentinel-3 OLCI level-2 tiling'),\n",
    "                ('abstract', 'This service takes as input one or more Sentinel-3 OLCI Level 2 (OL_2_LFR____) products and tiles'),\n",
    "                ('identifier', 'ewf-wfp-03-01-01')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter Definition "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Runtime parameter definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Input reference**\n",
    "\n",
    "The input identifier is the catalogue entry URL (a.k.a. self value)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "input_reference = dict([('identifier', 'input_reference'),\n",
    "                        ('title', 'Sentinel-3 OLCI Level 2 (OL_2_LFR____)'),\n",
    "                        ('abstract', 'Sentinel-3 OLCI Level 2 (OL_2_LFR____) catalogue reference'),\n",
    "                        ('value', 'https://catalog.terradue.com/sentinel3/search?uid=S3A_OL_2_LFR____20190101T080250_20190101T080550_20190102T125100_0179_039_363_2880_LN1_O_NT_002'),\n",
    "                        ('stac:collection', 'input_reference'),\n",
    "                        ('stac:href', 'catalog.json'),\n",
    "                        ('max_occurs', '16')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiling_level = dict([('identifier', 'tiling_level'),\n",
    "                ('value', '5'),\n",
    "                ('title', 'Tiling level'),\n",
    "                ('abstract', 'Tiling level'),\n",
    "                ('max_occurs', '1')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data path**\n",
    "\n",
    "This path defines where the data is staged-in. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = '/workspace/data/s3'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_catalog = '/workspace/data/s3/catalog.json'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import the packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['PREFIX'] = '/opt/anaconda/envs/env_s3/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "os.environ['PREFIX'] = '/opt/anaconda/envs/env_s3/'\n",
    "os.environ['GPT_BIN'] = os.path.join(os.environ['PREFIX'], 'snap/bin/gpt')\n",
    "sys.path.append('.')\n",
    "import gdal\n",
    "from gdal import gdalconst\n",
    "from helpers import *\n",
    "from shapely.wkt import loads\n",
    "from shapely.geometry import box\n",
    "from shapely.geometry import shape\n",
    "import shutil\n",
    "from pystac import Catalog, Collection, Item, MediaType, Asset, CatalogType\n",
    "from tiling import s3_tiles\n",
    "import glob\n",
    "import numpy as np\n",
    "gdal.UseExceptions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat = Catalog.from_file(input_catalog)\n",
    "\n",
    "if cat is None:\n",
    "    raise ValueError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "collection = next(cat.get_children())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "item = next(collection.get_items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<EOItem id=S3A_OL_2_LFR____20190101T080250_20190101T080550_20190102T125100_0179_039_363_2880_LN1_O_NT_002>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Sentinel-3 SLSTR product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operators = ['Read', \n",
    "             'Reproject',\n",
    "             'Write']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "read = dict()\n",
    "\n",
    "s3_path = item.assets['metadata'].get_absolute_href()\n",
    "\n",
    "read['file'] =  s3_path\n",
    "read['formatName'] = 'Sen3'\n",
    "\n",
    "reproject = dict()\n",
    "reproject['crs'] = 'EPSG:4326'\n",
    "\n",
    "write = dict()\n",
    "write['file'] = 's3_olci'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snap_graph(os.environ['GPT_BIN'],\n",
    "           operators,\n",
    "           Read=read, \n",
    "           Reproject=reproject,\n",
    "           Write=write)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def s3_to_tile(input_tif, item, tile):\n",
    "    \n",
    "    x_min, y_min, x_max, y_max = tile.tile.bounds\n",
    "    output_tile_name = '{}_L{}_C{}_R{}'.format(item.id,\n",
    "                                                    tile.level,\n",
    "                                                    tile.col,\n",
    "                                                    tile.row)\n",
    "\n",
    "    \n",
    "    gdal.Translate('tmp_{}.tif'.format(output_tile_name),\n",
    "                   input_tif,\n",
    "                   projWin=[x_min, y_max, x_max, y_min],\n",
    "                   projWinSRS='EPSG:4326',\n",
    "                   xRes=0.002934003239030, \n",
    "                   yRes=0.002934003239030,\n",
    "                   resampleAlg='bilinear')\n",
    "    \n",
    "    ds = gdal.Open('tmp_{}.tif'.format(output_tile_name),\n",
    "                   gdal.OF_READONLY)\n",
    "\n",
    "    gdal.SetConfigOption('COMPRESS_OVERVIEW', 'DEFLATE')\n",
    "    ds.BuildOverviews('NEAREST', [2,4,8,16,32])\n",
    "    ds = None\n",
    "    \n",
    "    \n",
    "    translate_options = gdal.TranslateOptions(gdal.ParseCommandLine(\"-co TILED=YES -co COPY_SRC_OVERVIEWS=YES -co COMPRESS=LZW\"))\n",
    "    ds = gdal.Open('tmp_{}.tif'.format(output_tile_name))\n",
    "    ds = gdal.Translate('{}.tif'.format(output_tile_name), ds, options=translate_options)\n",
    "    ds = None\n",
    "\n",
    "    band_names = ['NDVI', 'OGVI', 'OTCI', 'Land mask', 'Cloud mask', 'OGVI fail mask']\n",
    "\n",
    "\n",
    "    ###Re-open the tif file to set noData for 'NDVI', 'OGVI', 'OTCI'\n",
    "    \n",
    "    ds = gdal.Open('{}.tif'.format(output_tile_name), gdal.GA_Update)\n",
    "    for index in range(ds.RasterCount):\n",
    "\n",
    "        srcband = ds.GetRasterBand(index+1)\n",
    "        srcband.SetDescription(band_names[index])\n",
    "\n",
    "        if index <= 2:\n",
    "            srcband.SetNoDataValue(255)\n",
    "    \n",
    "    ds.FlushCache()\n",
    "    ds = None\n",
    "    \n",
    "    ###Drop generated tiles where land is less than Threshold=0.01\n",
    "    \n",
    "    ds = gdal.Open('{}.tif'.format(output_tile_name), gdal.GA_Update)\n",
    "    \n",
    "    # on borders mask and cloud-mask jumble non-binary values \n",
    "    # re-opening them as intgers renders them binary\n",
    "    \n",
    "    land_mask=np.array(ds.GetRasterBand(4).ReadAsArray(), dtype= np.uint8)\n",
    "    cloud_mask=np.array(ds.GetRasterBand(5).ReadAsArray(), dtype= np.uint8)\n",
    "\n",
    "    \n",
    "    if (land_mask==1).sum()/land_mask.size < 0.01 : \n",
    "        \n",
    "        os.remove('{}.tif'.format(output_tile_name))\n",
    "        print('removed {}.tif\\n'.format(output_tile_name))\n",
    "        print('land percentage was {}\\n ********\\n '.format((land_mask==1).sum()/land_mask.size))\n",
    "    else: \n",
    "        ndvi_tmp=ds.GetRasterBand(1).ReadAsArray()\n",
    "        ogvi_tmp=ds.GetRasterBand(2).ReadAsArray()\n",
    "        otci_tmp=ds.GetRasterBand(3).ReadAsArray()\n",
    "        # If land_mask=0 set data to noData\n",
    "    \n",
    "        masked_data = lambda x,y,z: 255 if y==0 or z==1 else x\n",
    "        vfunc_masked = np.vectorize(masked_data, otypes=[np.float])\n",
    "    \n",
    "    \n",
    "        updated_ndvi_data = vfunc_masked(ndvi_tmp, land_mask, cloud_mask)\n",
    "        updated_ogvi_data = vfunc_masked(ogvi_tmp, land_mask, cloud_mask)\n",
    "        updated_otci_data = vfunc_masked(otci_tmp, land_mask, cloud_mask)\n",
    "    \n",
    "        ds.GetRasterBand(1).WriteArray(updated_ndvi_data)\n",
    "        ds.GetRasterBand(2).WriteArray(updated_ogvi_data)\n",
    "        ds.GetRasterBand(3).WriteArray(updated_otci_data)\n",
    "        ds.GetRasterBand(4).WriteArray(land_mask)\n",
    "        ds.GetRasterBand(5).WriteArray(cloud_mask)\n",
    "\n",
    "        with open(output_tile_name + '.properties', 'w') as file:\n",
    "\n",
    "                file.write('title=Tile L:{1} C:{2} R:{3} {0}\\n'.format(item.id,\n",
    "                                                                  tile.level, \n",
    "                                                                  tile.col, \n",
    "                                                                  tile.row))\n",
    "\n",
    "                date='{}/{}'.format(item.datetime.strftime('%Y-%m-%dT%H:%M:%SZ'), \n",
    "                                             item.datetime.strftime('%Y-%m-%dT%H:%M:%SZ'))\n",
    "\n",
    "                file.write('date={}\\n'.format(date))\n",
    "\n",
    "                file.write('geometry={0}'.format(tile.tile.wkt))\n",
    "\n",
    "    for f in ['tmp_{}.tif'.format(output_tile_name), 'tmp_{}.tif.ovr'.format(output_tile_name)]:\n",
    "\n",
    "            if os.path.exists(f):\n",
    "\n",
    "                os.remove(f)\n",
    "\n",
    "    ds = None\n",
    "    return True\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tiling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "bands = [os.path.join('s3_olci.data', '{}.img'.format(band)) for band in ['OGVI', 'OTCI', 'RC681', 'RC865', 'LQSF']]\n",
    "        \n",
    "s3_data = read_s3(bands)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = gdal.Open(bands[0])\n",
    "\n",
    "geo_transform = ds.GetGeoTransform()\n",
    "projection_ref = ds.GetProjectionRef()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "ogvi = s3_data[:,:,0]\n",
    "otci= s3_data[:,:,1]\n",
    "red = s3_data[:,:,2]\n",
    "nir = s3_data[:,:,3]\n",
    "lqsf = s3_data[:,:,4]\n",
    "#otci_quality_flags=s3_data[:,:,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask = get_mask('LAND', lqsf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "cloud_mask =  get_mask('CLOUD', lqsf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "ogvi_fail_mask =  get_mask('OGVI_FAIL', lqsf)\n",
    "#if mask=1 then ogvi=255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate NDVI\n",
    "ndvi_lambda = lambda x,y,z,w,v: 255 if(x+y)==0 or z or w or v==0 else  (x-y)/float(x+y)\n",
    "vfunc_ndvi = np.vectorize(ndvi_lambda, otypes=[np.float])\n",
    "\n",
    "ndvi=vfunc_ndvi(nir, red, ogvi_fail_mask ,cloud_mask , mask)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver = gdal.GetDriverByName('GTiff')\n",
    "\n",
    "output = driver.Create('tmp.tif', \n",
    "                       ogvi.shape[1], \n",
    "                       ogvi.shape[0], \n",
    "                       6, \n",
    "                       gdal.GDT_Float32)\n",
    "\n",
    "output.SetGeoTransform(geo_transform)\n",
    "output.SetProjection(projection_ref)\n",
    "output.GetRasterBand(1).WriteArray(ndvi)\n",
    "output.GetRasterBand(2).WriteArray(ogvi)\n",
    "output.GetRasterBand(3).WriteArray(otci)\n",
    "output.GetRasterBand(4).WriteArray(mask)\n",
    "output.GetRasterBand(5).WriteArray(cloud_mask)\n",
    "output.GetRasterBand(6).WriteArray(ogvi_fail_mask)\n",
    "\n",
    "output.FlushCache()\n",
    "\n",
    "output = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<osgeo.gdal.Dataset; proxy of <Swig Object of type 'GDALDatasetShadow *' at 0x7f29b60f2cf0> >"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "warp_options=gdal.WarpOptions(gdal.ParseCommandLine(\"-srcnodata 255 -dstnodata 255\"))\n",
    "gdal.Warp('tmp_resampled.tif',\n",
    "                   'tmp.tif',\n",
    "                   dstSRS='EPSG:4326',\n",
    "                   xRes=0.002934003239030, \n",
    "                   yRes=0.002934003239030,\n",
    "                   resampleAlg=gdalconst.GRA_Average,\n",
    "                   # resampleAlg=gdalconst.GRA_Min,\n",
    "                   outputType = gdalconst.GDT_Float32,\n",
    "                   options=warp_options)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiles = s3_tiles(shape(item.geometry), int(tiling_level['value']))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>col</th>\n",
       "      <th>row</th>\n",
       "      <th>level</th>\n",
       "      <th>s3_tile</th>\n",
       "      <th>tile</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>35</td>\n",
       "      <td>16</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((19.71151 0.00000, 20.26610 2.51012, ...</td>\n",
       "      <td>POLYGON ((22.50000 0.00000, 22.50000 5.62500, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>36</td>\n",
       "      <td>16</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((28.12500 0.00000, 22.50000 0.00000, ...</td>\n",
       "      <td>POLYGON ((28.12500 0.00000, 28.12500 5.62500, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>35</td>\n",
       "      <td>17</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((20.93036 5.62500, 21.37750 7.77389, ...</td>\n",
       "      <td>POLYGON ((22.50000 5.62500, 22.50000 11.25000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>36</td>\n",
       "      <td>17</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((22.50000 10.29030, 22.53430 10.28350...</td>\n",
       "      <td>POLYGON ((28.12500 5.62500, 28.12500 11.25000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>37</td>\n",
       "      <td>17</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((28.12500 9.13097, 28.69560 9.00718, ...</td>\n",
       "      <td>POLYGON ((33.75000 5.62500, 33.75000 11.25000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>37</td>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((31.20270 -2.71122, 30.59250 -2.57559...</td>\n",
       "      <td>POLYGON ((33.75000 -5.62500, 33.75000 0.00000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>36</td>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((28.12500 -2.02324, 27.56510 -1.89755...</td>\n",
       "      <td>POLYGON ((28.12500 -5.62500, 28.12500 0.00000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>35</td>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((22.50000 -0.75603, 22.11240 -0.66795...</td>\n",
       "      <td>POLYGON ((22.50000 -5.62500, 22.50000 0.00000,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>37</td>\n",
       "      <td>16</td>\n",
       "      <td>5</td>\n",
       "      <td>POLYGON ((33.06729 5.62500, 32.98160 5.25293, ...</td>\n",
       "      <td>POLYGON ((33.75000 0.00000, 33.75000 5.62500, ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   col  row  level                                            s3_tile  \\\n",
       "0   35   16      5  POLYGON ((19.71151 0.00000, 20.26610 2.51012, ...   \n",
       "1   36   16      5  POLYGON ((28.12500 0.00000, 22.50000 0.00000, ...   \n",
       "2   35   17      5  POLYGON ((20.93036 5.62500, 21.37750 7.77389, ...   \n",
       "3   36   17      5  POLYGON ((22.50000 10.29030, 22.53430 10.28350...   \n",
       "4   37   17      5  POLYGON ((28.12500 9.13097, 28.69560 9.00718, ...   \n",
       "5   37   15      5  POLYGON ((31.20270 -2.71122, 30.59250 -2.57559...   \n",
       "6   36   15      5  POLYGON ((28.12500 -2.02324, 27.56510 -1.89755...   \n",
       "7   35   15      5  POLYGON ((22.50000 -0.75603, 22.11240 -0.66795...   \n",
       "8   37   16      5  POLYGON ((33.06729 5.62500, 32.98160 5.25293, ...   \n",
       "\n",
       "                                                tile  \n",
       "0  POLYGON ((22.50000 0.00000, 22.50000 5.62500, ...  \n",
       "1  POLYGON ((28.12500 0.00000, 28.12500 5.62500, ...  \n",
       "2  POLYGON ((22.50000 5.62500, 22.50000 11.25000,...  \n",
       "3  POLYGON ((28.12500 5.62500, 28.12500 11.25000,...  \n",
       "4  POLYGON ((33.75000 5.62500, 33.75000 11.25000,...  \n",
       "5  POLYGON ((33.75000 -5.62500, 33.75000 0.00000,...  \n",
       "6  POLYGON ((28.12500 -5.62500, 28.12500 0.00000,...  \n",
       "7  POLYGON ((22.50000 -5.62500, 22.50000 0.00000,...  \n",
       "8  POLYGON ((33.75000 0.00000, 33.75000 5.62500, ...  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removed S3A_OL_2_LFR____20190101T080250_20190101T080550_20190102T125100_0179_039_363_2880_LN1_O_NT_002_L5_C36_R15.tif\n",
      "\n",
      "land percentage was 0.0052069599925331075\n",
      " ********\n",
      " \n",
      "removed S3A_OL_2_LFR____20190101T080250_20190101T080550_20190102T125100_0179_039_363_2880_LN1_O_NT_002_L5_C35_R15.tif\n",
      "\n",
      "land percentage was 0.000858801449513169\n",
      " ********\n",
      " \n"
     ]
    }
   ],
   "source": [
    "for index, tile in tiles.iterrows():\n",
    "    \n",
    "    logging.info('Tile L{} C{} R{}'.format(tile.level,\n",
    "                                       tile.col,\n",
    "                                       tile.row))\n",
    "\n",
    "\n",
    "    s3_to_tile('tmp_resampled.tif', item, tile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "logging.info('Clean-up') \n",
    "os.remove('tmp.tif')\n",
    "os.remove('tmp_resampled.tif')\n",
    "\n",
    "shutil.rmtree('s3_olci.data')\n",
    "os.remove('s3_olci.dim')\n",
    "\n",
    "time.sleep(45)\n",
    "\n",
    "for f in glob.glob('./*.tif.aux.xml'):\n",
    "\n",
    "    os.remove(f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### License"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This work is licenced under a [Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0)](http://creativecommons.org/licenses/by-sa/4.0/) \n",
    "\n",
    "YOU ARE FREE TO:\n",
    "\n",
    "* Share - copy and redistribute the material in any medium or format.\n",
    "* Adapt - remix, transform, and built upon the material for any purpose, even commercially.\n",
    "\n",
    "UNDER THE FOLLOWING TERMS:\n",
    "\n",
    "* Attribution - You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.\n",
    "* ShareAlike - If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python env_s3",
   "language": "python",
   "name": "env_s3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}