Make_S2_ID_List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4fb31153",
   "metadata": {},
   "source": [
    "Daniel F Carlson Helmholtz-Zentrum Hereon \n",
    "daniel.carlson@hereon.de\n",
    "\n",
    "This notebook demonstrates how to:\n",
    "1. Generate a collection of Sentinel-2 images based on the criteria: bounding box, date range, and cloud cover\n",
    "2. Compute the footprint of the image to remove partial tiles\n",
    "3. Identify and remove duplicate tile IDs\n",
    "4. Write tile ids to a file\n",
    "\n",
    "This notebook uses Harmonized S2 L1C: https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_HARMONIZED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "79f66b11",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import os\n",
    "import ee\n",
    "import csv\n",
    "import geemap\n",
    "import geemap.colormaps as cm\n",
    "import numpy as np\n",
    "from IPython.display import display, HTML\n",
    "import ipywidgets as widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9c47cc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Authenticate\n",
    "ee.Authenticate()\n",
    "ee.Initialize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "18e9eaa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#cm.list_colormaps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f34d7753",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Functions\n",
    "# Define a function to compute the area of image footprints\n",
    "def computeFootprintArea(image):\n",
    "    footprint = image.geometry()\n",
    "    area_m2 = footprint.area()\n",
    "    return image.set({'footprint_area_m2': area_m2})\n",
    "\n",
    "# Function to check for duplicate images\n",
    "def check_s2_duplicates(imlist,vch=False):\n",
    "    im2pop = []\n",
    "    for x in range(0,len(imlist)):\n",
    "        chk_str = imlist[x]\n",
    "        chk_str_spl = chk_str.split('_')\n",
    "        chk_shrt = f\"{chk_str_spl[0][0:8]}_{chk_str_spl[2]}\"\n",
    "        for y in range(0,len(imlist)):\n",
    "            if y > x:\n",
    "                sec_str = imlist[y]\n",
    "                sec_str_spl = sec_str.split('_')\n",
    "                sec_shrt = f\"{sec_str_spl[0][0:8]}_{sec_str_spl[2]}\"\n",
    "\n",
    "                if chk_shrt == sec_shrt:\n",
    "                    if vch:\n",
    "                        print(f\"Found duplicate: {imlist[x]} and {imlist[y]}\")\n",
    "                    im2pop.append(y)\n",
    "    if im2pop==0:\n",
    "        return None\n",
    "    else:\n",
    "        im2pop_un = sorted(list(tuple(im2pop)))\n",
    "        for index in sorted(im2pop_un,reverse=True):\n",
    "            del imlist[index]\n",
    "        return imlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9edba40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now looking for S2_SR images between 2019-03-01 and 2019-03-31 with up to 40% cloud cover.\n",
      "Number of Sentinel-2 images in ROI: 610\n",
      "Number of images in the filtered collection: 404\n"
     ]
    }
   ],
   "source": [
    "# Set base directory\n",
    "base_dir = '/Users/dfc/Documents/MyPythonRepos/DFC_new/LABSEA_MCRO_GEE_S2'\n",
    "out_dir = os.path.join(base_dir,'tile_id_out')\n",
    "\n",
    "if not os.path.exists(out_dir):\n",
    "    os.mkdir(out_dir)\n",
    "\n",
    "# Define search years and months\n",
    "yrs = [2019,2020,2021,2022,2023]\n",
    "mns = [[3,31], [4,30], [5,31], [6,30], [7,31], [8,31], [9,30], [10,31] ]\n",
    "\n",
    "# Just looking (False). Or want to save (True)\n",
    "make_list = True\n",
    "\n",
    "# Set search year and month\n",
    "#srch_yr = 2019\n",
    "#srch_mn = '05'\n",
    "# Set min/max area for S2 tiles\n",
    "# Define the minimum and maximum allowable footprint area (in square meters)\n",
    "min_footprint_area = 5000000000  # Minimum area \n",
    "max_footprint_area = 50000000000  # Maximum area \n",
    "\n",
    "# roi \n",
    "fnm = 'NAtl_ROI.csv'\n",
    "fpath = os.path.join(base_dir,fnm)\n",
    "csv_data = []\n",
    "with open(fpath, 'r') as file:\n",
    "    reader = csv.reader(file)\n",
    "    for row in reader:\n",
    "        if not row[0][0] == 'L':\n",
    "            lat, lon = float(row[1]), float(row[0])\n",
    "            csv_data.append((lon, lat))\n",
    "if len(csv_data) > 0:\n",
    "    # Create a polygon geometry from the CSV data\n",
    "    roi = ee.Geometry.Polygon(csv_data)\n",
    "else:\n",
    "    roi = -10\n",
    "if not roi == -10:\n",
    "    \n",
    "    for y in yrs:\n",
    "        for m in mns:\n",
    "            # find S2 images in the ROI\n",
    "            # Define the time range for the image search\n",
    "            drng = [f\"{y}-{m[0]:02}-01\",f\"{y}-{m[0]:02}-{m[1]}\"]\n",
    "            start_date = drng[0]\n",
    "            end_date = drng[1]\n",
    "            # Define the maximum allowable cloud cover percentage\n",
    "            max_cloud_cover = 40  # Adjust as needed\n",
    "            \n",
    "            # initialize output file\n",
    "\n",
    "            if make_list:\n",
    "                imlist = []\n",
    "                outfnm = f'{y}_{m[0]:02}_Area_Thresh_S2_TOA_image_ids.csv'\n",
    "                outpath = os.path.join(out_dir,outfnm)\n",
    "\n",
    "            \n",
    "            print(f\"Now looking for S2 images between {start_date} and {end_date} with up to {max_cloud_cover}% cloud cover.\")\n",
    "\n",
    "            # Create a Sentinel-2 image collection\n",
    "            sentinel2_collection = ee.ImageCollection('COPERNICUS/S2_HARMONIZED') \\\n",
    "                .filterBounds(roi) \\\n",
    "                .filterDate(ee.Date(start_date), ee.Date(end_date)) \\\n",
    "                .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', max_cloud_cover))\n",
    "            # Print the number of images in the collection\n",
    "            print(\"Number of Sentinel-2 images in ROI:\", sentinel2_collection.size().getInfo())\n",
    "            # Map the function over the image collection to compute footprint areas\n",
    "            sentinel2_collection_with_area = sentinel2_collection.map(computeFootprintArea)\n",
    "\n",
    "            # Filter the collection based on footprint area\n",
    "            area_filtered_collection = sentinel2_collection_with_area \\\n",
    "                .filter(ee.Filter.gt('footprint_area_m2', min_footprint_area)) \\\n",
    "                .filter(ee.Filter.lt('footprint_area_m2', max_footprint_area))\n",
    "\n",
    "            # Get the size of the filtered collection (number of images)\n",
    "            area_collection_size = area_filtered_collection.size().getInfo()\n",
    "            print(\"Number of images in the filtered collection:\", area_collection_size)\n",
    "            if make_list:\n",
    "                f = open(outpath,'w')\n",
    "                f.close()\n",
    "                # Convert the image collection to a client-side list\n",
    "                image_list = area_filtered_collection.toList(sentinel2_collection.size())\n",
    "                for i in range(image_list.size().getInfo()):\n",
    "                    image_id = ee.Image(image_list.get(i)).id().getInfo()\n",
    "                    imlist.append(image_id)\n",
    "\n",
    "                imlist_out = check_s2_duplicates(imlist)\n",
    "                if imlist_out is None:\n",
    "                    print(\"Well that's awkward. Something went wrong somewhere...\")\n",
    "                else:\n",
    "                    for il in imlist_out:\n",
    "                        with open(outpath, 'a') as f:\n",
    "                            print(f\"Now writing {il} to file\")\n",
    "                            pstr = f\"{il},\\n\"\n",
    "                            f.write(pstr)\n",
    "                            f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "482e0e6f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}