c6s_S2_batch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "53dbc5d4-d7e3-43dd-bd5a-98ab7709190b",
   "metadata": {},
   "source": [
    "# Corrección atmosférica en bucle\n",
    "\n",
    "A continuación se detalla la modificación del código de Sam Murphy realizada para corregir en bucle todas las imágenes de una colección.\n",
    "\n",
    "## Incluir paquetes necesarios e iniciar GEE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3675029-762e-41a2-ac92-086fa9d30304",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment the following line if condacolab is not installed\n",
    "!pip install -q condacolab"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe53ba71-c41b-4d20-8206-4f7e4511cb56",
   "metadata": {},
   "source": [
    "**Importante**: Cuando se termina de ejecutar `condacolab.install()` el kernel se reinicia. Deberá volverse a ecutar el código y devolverá el mensaje \"Everything looks OK!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0f55b3e-cc33-4f05-93da-643e37ae27d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load conda commands\n",
    "import condacolab\n",
    "condacolab.install()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79477dd0-8efc-4233-8470-f3149b8ad0b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download Py6S module and 6S compiled model\n",
    "!conda install conda-forge::py6s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9997c0f-3316-488d-8a37-b1a6504b52d0",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "cellView": "form"
   },
   "outputs": [],
   "source": [
    "#@title Load Atmospheric (funciones atmospheric.py)\n",
    "\"\"\"\n",
    "atmospheric.py, Sam Murphy (2016-10-26)\n",
    "\n",
    "Atmospheric water vapour, ozone and AOT from GEE\n",
    "\n",
    "Usage\n",
    "H2O = Atmospheric.water(geom,date)\n",
    "O3 = Atmospheric.ozone(geom,date)\n",
    "AOT = Atmospheric.aerosol(geom,date)\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# El modulo ee sera importado mas adelante\n",
    "# import ee\n",
    "\n",
    "class Atmospheric():\n",
    "\n",
    "  def round_date(date,xhour):\n",
    "    \"\"\"\n",
    "    rounds a date of to the closest 'x' hours\n",
    "    \"\"\"\n",
    "    y = date.get('year')\n",
    "    m = date.get('month')\n",
    "    d = date.get('day')\n",
    "    H = date.get('hour')\n",
    "    HH = H.divide(xhour).round().multiply(xhour)\n",
    "    return date.fromYMD(y,m,d).advance(HH,'hour')\n",
    "\n",
    "  def round_month(date):\n",
    "    \"\"\"\n",
    "    round date to closest month\n",
    "    \"\"\"\n",
    "    # start of THIS month\n",
    "    m1 = date.fromYMD(date.get('year'),date.get('month'),ee.Number(1))\n",
    "\n",
    "    # start of NEXT month\n",
    "    m2 = m1.advance(1,'month')\n",
    "\n",
    "    # difference from date\n",
    "    d1 = ee.Number(date.difference(m1,'day')).abs()\n",
    "    d2 = ee.Number(date.difference(m2,'day')).abs()\n",
    "\n",
    "    # return closest start of month\n",
    "    return ee.Date(ee.Algorithms.If(d2.gt(d1),m1,m2))\n",
    "\n",
    "\n",
    "\n",
    "  def water(geom,date):\n",
    "    \"\"\"\n",
    "    Water vapour column above target at time of image aquisition.\n",
    "\n",
    "    (Kalnay et al., 1996, The NCEP/NCAR 40-Year Reanalysis Project. Bull.\n",
    "    Amer. Meteor. Soc., 77, 437-471)\n",
    "    \"\"\"\n",
    "\n",
    "    # Point geometry required\n",
    "    centroid = geom.centroid()\n",
    "\n",
    "    # H2O datetime is in 6 hour intervals\n",
    "    H2O_date = Atmospheric.round_date(date,6)\n",
    "\n",
    "    # filtered water collection\n",
    "    water_ic = ee.ImageCollection('NCEP_RE/surface_wv').filterDate(H2O_date, H2O_date.advance(1,'month'))\n",
    "\n",
    "    # water image\n",
    "    water_img = ee.Image(water_ic.first())\n",
    "\n",
    "    # water_vapour at target\n",
    "    water = water_img.reduceRegion(reducer=ee.Reducer.mean(), geometry=centroid).get('pr_wtr')\n",
    "\n",
    "    # convert to Py6S units (Google = kg/m^2, Py6S = g/cm^2)\n",
    "    water_Py6S_units = ee.Number(water).divide(10)\n",
    "\n",
    "    return water_Py6S_units\n",
    "\n",
    "\n",
    "\n",
    "  def ozone(geom,date):\n",
    "    \"\"\"\n",
    "    returns ozone measurement from merged TOMS/OMI dataset\n",
    "\n",
    "    OR\n",
    "\n",
    "    uses our fill value (which is mean value for that latlon and day-of-year)\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Point geometry required\n",
    "    centroid = geom.centroid()\n",
    "\n",
    "    def ozone_measurement(centroid,O3_date):\n",
    "\n",
    "      # filtered ozone collection\n",
    "      ozone_ic = ee.ImageCollection('TOMS/MERGED').filterDate(O3_date, O3_date.advance(1,'month'))\n",
    "\n",
    "      # ozone image\n",
    "      ozone_img = ee.Image(ozone_ic.first())\n",
    "\n",
    "      # ozone value IF TOMS/OMI image exists ELSE use fill value\n",
    "      ozone = ee.Algorithms.If(ozone_img,\\\n",
    "      ozone_img.reduceRegion(reducer=ee.Reducer.mean(), geometry=centroid).get('ozone'),\\\n",
    "      ozone_fill(centroid,O3_date))\n",
    "\n",
    "      return ozone\n",
    "\n",
    "    def ozone_fill(centroid,O3_date):\n",
    "      \"\"\"\n",
    "      Gets our ozone fill value (i.e. mean value for that doy and latlon)\n",
    "\n",
    "      you can see it\n",
    "      1) compared to LEDAPS: https://code.earthengine.google.com/8e62a5a66e4920e701813e43c0ecb83e\n",
    "      2) as a video: https://www.youtube.com/watch?v=rgqwvMRVguI&feature=youtu.be\n",
    "\n",
    "      \"\"\"\n",
    "\n",
    "      # ozone fills (i.e. one band per doy)\n",
    "      ozone_fills = ee.ImageCollection('users/samsammurphy/public/ozone_fill').toList(366)\n",
    "\n",
    "      # day of year index\n",
    "      jan01 = ee.Date.fromYMD(O3_date.get('year'),1,1)\n",
    "      doy_index = date.difference(jan01,'day').toInt()# (NB. index is one less than doy, so no need to +1)\n",
    "\n",
    "      # day of year image\n",
    "      fill_image = ee.Image(ozone_fills.get(doy_index))\n",
    "\n",
    "      # return scalar fill value\n",
    "      return fill_image.reduceRegion(reducer=ee.Reducer.mean(), geometry=centroid).get('ozone')\n",
    "\n",
    "    # O3 datetime in 24 hour intervals\n",
    "    O3_date = Atmospheric.round_date(date,24)\n",
    "\n",
    "    # TOMS temporal gap\n",
    "    TOMS_gap = ee.DateRange('1994-11-01','1996-08-01')\n",
    "\n",
    "    # avoid TOMS gap entirely\n",
    "    ozone = ee.Algorithms.If(TOMS_gap.contains(O3_date),ozone_fill(centroid,O3_date),ozone_measurement(centroid,O3_date))\n",
    "\n",
    "    # fix other data gaps (e.g. spatial, missing images, etc..)\n",
    "    ozone = ee.Algorithms.If(ozone,ozone,ozone_fill(centroid,O3_date))\n",
    "\n",
    "    #convert to Py6S units\n",
    "    ozone_Py6S_units = ee.Number(ozone).divide(1000)# (i.e. Dobson units are milli-atm-cm )\n",
    "\n",
    "    return ozone_Py6S_units\n",
    "\n",
    "\n",
    "  def aerosol(geom,date):\n",
    "    \"\"\"\n",
    "    Aerosol Optical Thickness.\n",
    "\n",
    "    try:\n",
    "      MODIS Aerosol Product (monthly)\n",
    "    except:\n",
    "      fill value\n",
    "    \"\"\"\n",
    "\n",
    "    def aerosol_fill(date):\n",
    "      \"\"\"\n",
    "      MODIS AOT fill value for this month (i.e. no data gaps)\n",
    "      \"\"\"\n",
    "      return ee.Image('users/samsammurphy/public/AOT_stack')\\\n",
    "               .select([ee.String('AOT_').cat(date.format('M'))])\\\n",
    "               .rename(['AOT_550'])\n",
    "\n",
    "\n",
    "    def aerosol_this_month(date):\n",
    "      \"\"\"\n",
    "      MODIS AOT original data product for this month (i.e. some data gaps)\n",
    "      \"\"\"\n",
    "      # image for this month\n",
    "      img =  ee.Image(\\\n",
    "                      ee.ImageCollection('MODIS/006/MOD08_M3')\\\n",
    "                        .filterDate(Atmospheric.round_month(date))\\\n",
    "                        .first()\\\n",
    "                     )\n",
    "\n",
    "      # fill missing month (?)\n",
    "      img = ee.Algorithms.If(img,\\\n",
    "                               # all good\n",
    "                               img\\\n",
    "                               .select(['Aerosol_Optical_Depth_Land_Mean_Mean_550'])\\\n",
    "                               .divide(1000)\\\n",
    "                               .rename(['AOT_550']),\\\n",
    "                              # missing month\n",
    "                                aerosol_fill(date))\n",
    "\n",
    "      return img\n",
    "\n",
    "\n",
    "    def get_AOT(AOT_band,geom):\n",
    "      \"\"\"\n",
    "      AOT scalar value for target\n",
    "      \"\"\"\n",
    "      return ee.Image(AOT_band).reduceRegion(reducer=ee.Reducer.mean(),\\\n",
    "                                 geometry=geom.centroid())\\\n",
    "                                .get('AOT_550')\n",
    "\n",
    "\n",
    "    after_modis_start = date.difference(ee.Date('2000-03-01'),'month').gt(0)\n",
    "\n",
    "    AOT_band = ee.Algorithms.If(after_modis_start, aerosol_this_month(date), aerosol_fill(date))\n",
    "\n",
    "    AOT = get_AOT(AOT_band,geom)\n",
    "\n",
    "    AOT = ee.Algorithms.If(AOT,AOT,get_AOT(aerosol_fill(date),geom))\n",
    "    # i.e. check reduce region worked (else force fill value)\n",
    "\n",
    "    return AOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03b083a0-f792-4782-97b4-6d7bf448fdf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load mandatory modules\n",
    "import ee\n",
    "from Py6S import *\n",
    "import datetime\n",
    "import math\n",
    "import os\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97216fc1-05df-44d5-9559-02f8c8ecb3f5",
   "metadata": {},
   "source": [
    "Iniciar la API de EarthEngine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcc35f99-12e3-4135-bf52-168456ce6c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "ee.Authenticate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef9b4f0-2f4c-47af-abca-37ea8104cf29",
   "metadata": {},
   "source": [
    "Inicializar un proyecto de Google Cloud en el que se encuentre activada la API de Earth Engine. El proyecto debe estar vinculado con la cuenta de google para la que se ha realizado el registro con `ee.Authenticate()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b078fb3-e489-4bc2-915b-dbda54f5fc79",
   "metadata": {},
   "outputs": [],
   "source": [
    "ee.Initialize(project='id') # Project ID"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac7f082-899e-4602-9621-e7b033d48388",
   "metadata": {},
   "source": [
    "Definir la función que aplica la constante para obtener valores de reflectividad a TOA en las imágenes de la colección COPERNICUS/S2_HARMONIZED. Permite conservar las propiedades de la imagen original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57faff5b-7fbc-4838-beab-ed3ffccd1a45",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reflectance(img):\n",
    "  \"\"\"\n",
    "  Convert to reflectance values and mantain original image properties.\n",
    "\n",
    "  The 'system:index' property is written inside fileID key due to:\n",
    "  - It's not added in the exported image\n",
    "  - This property is mandatory to perform JOIN operation with\n",
    "  COPERNICUS/S2_CLOUD_PROBABILITY image collection.\n",
    "  \"\"\"\n",
    "  r = img.divide(10000)\n",
    "  # Set new property\n",
    "  r = r.set('fileID', img.id())\n",
    "  # Get property names in the original image\n",
    "  props = img.propertyNames()\n",
    "  # Return the new image with the original image properties\n",
    "  return r.copyProperties(img, props)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b01a6c-d380-4df7-8d68-f28a61b7d292",
   "metadata": {},
   "source": [
    "## Definir funciones de corrección \n",
    "\n",
    "Se definen las tres funciones creadas por Sam Murphy para:\n",
    "\n",
    "1. Obtener la respuesta espectral de las bandas Sentinel 2.\n",
    "2. Convertir valores de reflectividad en TOA a valores de radiancia.\n",
    "3. Aplicar la corrección atmosférica. Devuelve valores de reflectividad a BOA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06b1dada-7faa-4999-b625-a00a72830585",
   "metadata": {},
   "outputs": [],
   "source": [
    "def spectralResponseFunction(bandname):\n",
    "\n",
    "  \"\"\"\n",
    "  Extract spectral response from predefined Sentinel2 bands.\n",
    "  Use PredefinedWavelengths class in Py6s module.\n",
    "  \"\"\"\n",
    "  bandSelect = {\n",
    "    'B1':PredefinedWavelengths.S2A_MSI_01,\n",
    "    'B2':PredefinedWavelengths.S2A_MSI_02,\n",
    "    'B3':PredefinedWavelengths.S2A_MSI_03,\n",
    "    'B4':PredefinedWavelengths.S2A_MSI_04,\n",
    "    'B5':PredefinedWavelengths.S2A_MSI_05,\n",
    "    'B6':PredefinedWavelengths.S2A_MSI_06,\n",
    "    'B7':PredefinedWavelengths.S2A_MSI_07,\n",
    "    'B8':PredefinedWavelengths.S2A_MSI_08,\n",
    "    'B8A':PredefinedWavelengths.S2A_MSI_8A,\n",
    "    'B9':PredefinedWavelengths.S2A_MSI_09,\n",
    "    'B10':PredefinedWavelengths.S2A_MSI_10,\n",
    "    'B11':PredefinedWavelengths.S2A_MSI_11,\n",
    "    'B12':PredefinedWavelengths.S2A_MSI_12\n",
    "  }\n",
    "  return Wavelength(bandSelect[bandname])\n",
    "\n",
    "def toa_to_rad(toa, bandname, info, solar_z, scene_date):\n",
    "  \"\"\"\n",
    "  Convert TOA reflectance to Radiance units (values to perform 6S correction)\n",
    "  \"\"\"\n",
    "  # Get metadata from S2 image\n",
    "  ESUN = info['SOLAR_IRRADIANCE_'+bandname]\n",
    "  solar_angle_correction = math.cos(math.radians(solar_z))\n",
    "  # Compute Earth-Sun distance (doy)\n",
    "  doy = scene_date.timetuple().tm_yday\n",
    "  d = 1 - 0.01672 * math.cos(0.9856 * (doy-4))\n",
    "  # http://physics.stackexchange.com/\n",
    "  # questions/177949/earth-sun-distance-on-a-given-day-of-the-year\n",
    "\n",
    "  # Conversion factor\n",
    "  multiplier = ESUN*solar_angle_correction/(math.pi*d**2)\n",
    "  # Apply radiance equation\n",
    "  rad = toa.select(bandname).multiply(multiplier)\n",
    "  return rad\n",
    "\n",
    "def surface_reflectance(s, toa, bandname, info, solar_z, scene_date):\n",
    "  \"\"\"\n",
    "  Compute BOA reflectance (wavelenght related) with 6S outputs.\n",
    "  \"\"\"\n",
    "  # Include to s object the current band spectral response\n",
    "  s.wavelength = spectralResponseFunction(bandname)\n",
    "\n",
    "  # Execute 6S model\n",
    "  s.run()\n",
    "\n",
    "  # Extract atmospheric terms\n",
    "  Edir = s.outputs.direct_solar_irradiance # Direct solar irradiance\n",
    "  Edif = s.outputs.diffuse_solar_irradiance # Diffuse solar irradiance\n",
    "  Lp = s.outputs.atmospheric_intrinsic_radiance # Path radiance\n",
    "  absorb = s.outputs.trans['global_gas'].upward # Absorption transmissivity\n",
    "  scatter = s.outputs.trans['total_scattering'].upward # Scattering transmissivity\n",
    "  tau2 = absorb*scatter # Total transmissivity\n",
    "\n",
    "  # Get radiance values\n",
    "  rad = toa_to_rad(toa, bandname, info, solar_z, scene_date)\n",
    "  # Compute the equation to get BOA reflectance\n",
    "  ref = rad.subtract(Lp).multiply(math.pi).divide(tau2*(Edir+Edif))\n",
    "\n",
    "  return ref"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d853aa8-19de-4454-9caf-665c55acf29d",
   "metadata": {},
   "source": [
    "## Definir el AOI sobre el que corregir la imagen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9db59231-0940-4502-b2b1-eb7385b89028",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Study area from which:\n",
    "# - Image collection is filtered\n",
    "# - Region to export the corrected image\n",
    "# - Atmospheric parameters are extracted\n",
    "geom = ee.Geometry.Polygon([\n",
    "    [-0.9570796519011493,40.98197275411647],\n",
    "    [-0.5670650034636493,40.98197275411647],\n",
    "    [-0.5670650034636493,41.45919658393617],\n",
    "    [-0.9570796519011493,41.45919658393617],\n",
    "    [-0.9570796519011493,40.98197275411647]])\n",
    "\n",
    "# Another option to create a geom study area\n",
    "# geom = ee.Geometry.Rectangle(-0.996, 41.508, -0.568, 40.992)\n",
    "\n",
    "# Get BBOX coordinates (used to export the corrected image inside its AOI)\n",
    "region = geom.bounds().getInfo()['coordinates']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0630f5fd-3a94-45a9-92c3-8c2c61f26c3c",
   "metadata": {},
   "source": [
    "## Definir función de corrección en bucle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bee8afd3-cbb6-44ef-953b-a691651a2ceb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conversion(img, asset_id):\n",
    "  \"\"\"\n",
    "  Atmospherically correction of all images in an Image Collection.\n",
    "  \"\"\"\n",
    "  # Save image adquisition date\n",
    "  date = img.date()\n",
    "\n",
    "  # Compute TOA reflectance\n",
    "  toa = ee.Image(reflectance(img))\n",
    "\n",
    "  # Write image metadata\n",
    "  info = img.getInfo()['properties']\n",
    "\n",
    "  # Scene date: Python uses seconds, EE miliseconds\n",
    "  miliseconds = info['system:time_start']/1000\n",
    "  scene_date = datetime.datetime.utcfromtimestamp(miliseconds)\n",
    "\n",
    "  # Solar zenith angle\n",
    "  solar_z = info['MEAN_SOLAR_ZENITH_ANGLE']\n",
    "\n",
    "  # Atmospheric components\n",
    "  # (functions created by Sam Murphy and load in an above chunk)\n",
    "  h2o = Atmospheric.water(geom,date).getInfo()\n",
    "  o3 = Atmospheric.ozone(geom,date).getInfo()\n",
    "  # Atmospheric Optical Thickness\n",
    "  aot = Atmospheric.aerosol(geom,date).getInfo()\n",
    "\n",
    "  # Elevation from Shuttle Radar Topography mission (STRM) collection\n",
    "  SRTM = ee.Image('CGIAR/SRTM90_V4')\n",
    "\n",
    "  # Get elevation of the AOI center\n",
    "  alt = SRTM.reduceRegion(**{\n",
    "    'reducer': ee.Reducer.mean(),\n",
    "    'geometry': geom.centroid()}).get('elevation').getInfo()\n",
    "\n",
    "  # Transform to kilometers, units used in Py6s\n",
    "  km = alt/1000\n",
    "\n",
    "  # 6S backbone\n",
    "  s = SixS()\n",
    "  # Load atmospheric components\n",
    "  s.atmos_profile = AtmosProfile.UserWaterAndOzone(h2o,o3)\n",
    "  s.aero_profile = AeroProfile.Continental\n",
    "  s.aot550 = aot\n",
    "  # Geometry Earth-Sun-Satellite\n",
    "  s.geometry = Geometry.User()\n",
    "  s.geometry.view_z = 0 # NADIR\n",
    "  s.geometry.solar_z = solar_z # Solar zenith angle\n",
    "  s.geometry.month = scene_date.month # month to compute Earth-Sun distance\n",
    "  s.geometry.day = scene_date.day # Day to compute Earth-Sun distance\n",
    "  s.altitudes.set_sensor_satellite_level()\n",
    "  s.altitudes.set_target_custom_altitude(km) # Surface altitude\n",
    "\n",
    "  # Apply conversion over each image band\n",
    "  output = img.select('QA60')\n",
    "  # Wavelenght dependent\n",
    "  for band in ['B2','B3','B4','B5','B6','B7','B8','B8A','B11','B12']:\n",
    "    # 6S Atmospheric Correction\n",
    "    boa = surface_reflectance(s, toa, band, info, solar_z, scene_date)\n",
    "    # Add correction band inside the output image\n",
    "    output = output.addBands(boa)\n",
    "\n",
    "  # Export corrected image\n",
    "  # 1. Write additional custom properties\n",
    "  dateString = scene_date.strftime(\"%Y-%m-%d\")\n",
    "\n",
    "  ref = output.set({\n",
    "    'satellite':'Sentinel 2',\n",
    "    'date':dateString,\n",
    "    'aerosol_optical_thickness':aot,\n",
    "    'water_vapour':h2o,\n",
    "    'ozone':o3\n",
    "  })\n",
    "  # Add new properties to the image original ones\n",
    "  props = toa.propertyNames()\n",
    "  ref = ref.copyProperties(toa, props)\n",
    "\n",
    "  # Image name (inside GEE Asset path)\n",
    "  image_id = asset_id + 'S2SR_' + dateString\n",
    "\n",
    "  # 2. Export options\n",
    "  params = {\n",
    "    'image': ee.Image(ref),\n",
    "    'description': 'sentinel2_atmcorr_export',\n",
    "    'assetId': image_id,\n",
    "    'region': region,\n",
    "    'crs': 'EPSG:4326',\n",
    "    'scale': 20\n",
    "  }\n",
    "  # Create export task\n",
    "  export = ee.batch.Export.image.toAsset(**params)\n",
    "\n",
    "  # 3. Initialize task\n",
    "  export.start()\n",
    "  return print(\"Imagen \" + image_id + \" en proceso de descarga.\")\n",
    "\n",
    "##"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ab0a612-bc19-408c-9d53-931a13369d1b",
   "metadata": {},
   "source": [
    "## Iniciar la corrección en bucle\n",
    "\n",
    "Aplicar la funcion de conversion en bucle a una coleccion GEE. Primero se define la colección y despues se aplica la conversión dentro de un bucle a todas las imágenes que contiene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c476ec17-2a6d-4a63-9320-d4aa5bdeb94a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define image collection\n",
    "S2 = (ee.ImageCollection('COPERNICUS/S2_HARMONIZED')\n",
    "  .filterBounds(geom)\n",
    "  .filterDate('2015-10-01','2017-04-30')\n",
    "  .filterMetadata('MGRS_TILE', 'equals', '30TXL')\n",
    "  .filterMetadata('CLOUDY_PIXEL_PERCENTAGE', 'less_than', 20)\n",
    "  .sort('system:time_start')\n",
    "  .distinct('system:time_start'))\n",
    "\n",
    "# Definir en una lista las imagenes a filtrar\n",
    "features = S2.getInfo()['features']\n",
    "\n",
    "# Definir la carpeta de destino (dentro de GEE)\n",
    "assetID = 'users/iranzocristian/6s_test_2023/'\n",
    "\n",
    "\n",
    "# CORRECCION DE LA COLECCION AUTOMATICAMENTE (bucle for)\n",
    "# 1. Recorre cada imagen de la lista anterior\n",
    "# 2. Obtiene su id\n",
    "# 3. Se llama a la imagen de la coleccion GEE con el id anterior\n",
    "# 4. Se aplica la funcion de conversion principal\n",
    "for i in features:\n",
    "  id = i['id']\n",
    "  conversion(ee.Image(id), assetID)\n",
    "##"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88feded1-6eec-4b61-99a5-e7885cbb02c4",
   "metadata": {},
   "source": [
    "## Cargar la coleccion de imagenes corregidas\n",
    "\n",
    "En la API de JavaScript (code editor) debería incluirse el siguiente código:\n",
    "\n",
    "```javascript\n",
    "var assetList = ee.data.listAssets(\"users/iranzocristian/6s_test_2023\")['assets']\n",
    "                    .map(function(d) { return d.name })\n",
    "var collection = ee.ImageCollection(assetList)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b7916e5-b48a-444d-8c57-4a692e86639d",
   "metadata": {},
   "outputs": [],
   "source": [
    "assetList = ee.data.listAssets(\"users/iranzocristian/6s_test_2023\")['assets']\n",
    "assetNames = [i['name'] for i in assetList]\n",
    "collection = ee.ImageCollection(assetNames)\n",
    "print('Has cargado una colección con ' + str(collection.size().getInfo()) + ' imgs corregidas.')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}