CreateRiverMask.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35d68edd",
   "metadata": {},
   "source": [
    "# River mask development using DSWE/Landsat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099bf1a1",
   "metadata": {},
   "source": [
    "The following code uses the DWSE watermasking method and Landsat remote sensing data to develop two-dimensional water masks of rivers within the given study area, drawing on locally stored shapefiles for study boundaries and Google Earth Engine for Landsat imagery. Executing the export_masks() function in step 7 generates median annual composite water masks for the for the specified range of years for the given watershed, exporting them as .tif files to Google Drive.\n",
    "\n",
    "Author: James (Huck) Rees;\n",
    "        PhD Student, UCSB Geography\n",
    "        \n",
    "Date: May 9th, 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "519abe95",
   "metadata": {},
   "source": [
    "## Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d6302eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ee\n",
    "import geemap\n",
    "import geopandas as gpd\n",
    "import os\n",
    "from datetime import datetime\n",
    "import math\n",
    "ee.Initialize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f70798d3",
   "metadata": {},
   "source": [
    "## Initialize functions for DSWE water masking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "972c89ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function _set_css_in_cell_output at 0x0000024A4DC6F600> (for pre_run_cell), with arguments args (<ExecutionInfo object at 24a4e156bd0, raw_cell=\"# Normalized Difference Water Index (MNDWI)\n",
      "def Mn..\" store_history=True silent=False shell_futures=True cell_id=None>,),kwargs {}:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "_set_css_in_cell_output() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;31mTypeError\u001b[0m: _set_css_in_cell_output() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "# Normalized Difference Water Index (MNDWI)\n",
    "def Mndwi(image):\n",
    "    \"\"\"\n",
    "    Calculate the Modified Normalized Difference Water Index (MNDWI) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the MNDWI band named 'mndwi'.\n",
    "    \"\"\"\n",
    "    return image.normalizedDifference(['Green', 'Swir1']).rename('mndwi')\n",
    "\n",
    "# Modified Bare Soil Reflectance Variables\n",
    "def Mbsrv(image):\n",
    "    \"\"\"\n",
    "    Calculate the Modified Bare Soil Reflectance Variable (MBSRV) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the MBSRV band named 'mbsrv'.\n",
    "    \"\"\"\n",
    "    return image.select(['Green']).add(image.select(['Red'])).rename('mbsrv')\n",
    "\n",
    "def Mbsrn(image):\n",
    "    \"\"\"\n",
    "    Calculate the Modified Bare Soil Reflectance Normalized (MBSRN) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the MBSRN band named 'mbsrn'.\n",
    "    \"\"\"\n",
    "    return image.select(['Nir']).add(image.select(['Swir1'])).rename('mbsrn')\n",
    "\n",
    "# Normalized Difference Vegetation Index (NDVI)\n",
    "def Ndvi(image):\n",
    "    \"\"\"\n",
    "    Calculate the Normalized Difference Vegetation Index (NDVI) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the NDVI band named 'ndvi'.\n",
    "    \"\"\"\n",
    "    return image.normalizedDifference(['Nir', 'Red']).rename('ndvi')\n",
    "\n",
    "# Automated Water Extraction Index (AWESH)\n",
    "def Awesh(image):\n",
    "    \"\"\"\n",
    "    Calculate the Automated Water Extraction Index (AWEsh) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image with the necessary bands for MBSRN calculation.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the AWEsh band named 'awesh'.\n",
    "    \"\"\"\n",
    "    return image.expression(\n",
    "        'Blue + 2.5 * Green + (-1.5) * mbsrn + (-0.25) * Swir2',\n",
    "        {\n",
    "            'Blue': image.select(['Blue']),\n",
    "            'Green': image.select(['Green']),\n",
    "            'mbsrn': Mbsrn(image).select(['mbsrn']),\n",
    "            'Swir2': image.select(['Swir2'])\n",
    "        }\n",
    "    ).rename('awesh')\n",
    "\n",
    "# Decision Tree for Surface Water Extent (DSWE)\n",
    "def Dswe(image):\n",
    "    \"\"\"\n",
    "    Calculate the Decision Tree for Surface Water Extent (DSWE) for a given image.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image with bands required for the DSWE calculation.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The resulting image with the DSWE classification named 'dswe'.\n",
    "    \"\"\"\n",
    "    mndwi = Mndwi(image)\n",
    "    mbsrv = Mbsrv(image)\n",
    "    mbsrn = Mbsrn(image)\n",
    "    awesh = Awesh(image)\n",
    "    swir1 = image.select(['Swir1'])\n",
    "    nir = image.select(['Nir'])\n",
    "    ndvi = Ndvi(image)\n",
    "    blue = image.select(['Blue'])\n",
    "    swir2 = image.select(['Swir2'])\n",
    "\n",
    "    # Decision tree thresholds\n",
    "    t1 = mndwi.gt(0.124)\n",
    "    t2 = mbsrv.gt(mbsrn)\n",
    "    t3 = awesh.gt(0)\n",
    "    t4 = (mndwi.gt(-0.44)\n",
    "          .And(swir1.lt(0.09))\n",
    "          .And(nir.lt(0.15))\n",
    "          .And(ndvi.lt(0.7)))\n",
    "    t5 = (mndwi.gt(-0.5)\n",
    "          .And(blue.lt(0.1))\n",
    "          .And(swir1.lt(0.3))\n",
    "          .And(swir2.lt(0.1))\n",
    "          .And(nir.lt(0.25)))\n",
    "\n",
    "    # Combine results using weights to create unique classes\n",
    "    t = t1.add(t2.multiply(10)).add(t3.multiply(100)).add(t4.multiply(1000)).add(t5.multiply(10000))\n",
    "\n",
    "    # Define DSWE classification levels\n",
    "    noWater = t.eq(0).Or(t.eq(1)).Or(t.eq(10)).Or(t.eq(100)).Or(t.eq(1000))\n",
    "    hWater = t.eq(1111).Or(t.eq(10111)).Or(t.eq(11011)).Or(t.eq(11101)).Or(t.eq(11110)).Or(t.eq(11111))\n",
    "    mWater = (t.eq(111).Or(t.eq(1011)).Or(t.eq(1101)).Or(t.eq(1110))\n",
    "              .Or(t.eq(10011)).Or(t.eq(10101)).Or(t.eq(10110))\n",
    "              .Or(t.eq(11001)).Or(t.eq(11010)).Or(t.eq(11100)))\n",
    "    pWetland = t.eq(11000)\n",
    "    lWater = (t.eq(11).Or(t.eq(101)).Or(t.eq(110)).Or(t.eq(1001))\n",
    "              .Or(t.eq(1010)).Or(t.eq(1100)).Or(t.eq(10000))\n",
    "              .Or(t.eq(10001)).Or(t.eq(10010)).Or(t.eq(10100)))\n",
    "\n",
    "    # Assign classification levels to DSWE\n",
    "    iDswe = (noWater.multiply(0)\n",
    "             .add(hWater.multiply(1))\n",
    "             .add(mWater.multiply(2))\n",
    "             .add(pWetland.multiply(3))\n",
    "             .add(lWater.multiply(4)))\n",
    "\n",
    "    return iDswe.rename(['dswe'])\n",
    "\n",
    "# Generate Binary Water Mask Based on DSWE\n",
    "def ClassifyWaterJones2019(image, max_level):\n",
    "    \"\"\"\n",
    "    Creates a binary water mask from an input image using DSWE classification.\n",
    "    \n",
    "    Args:\n",
    "        image: The input image containing relevant bands and indices.\n",
    "        max_level: The maximum classification level (inclusive) to include in the mask.\n",
    "    \n",
    "    Returns:\n",
    "        ee.Image: A single-band image representing the binary water mask.\n",
    "    \"\"\"\n",
    "    dswe = Dswe(image)\n",
    "    # Start with level 1 (high-confidence water)\n",
    "    water_mask = dswe.eq(1)\n",
    "\n",
    "    # Add higher levels if within the specified max level\n",
    "    for level in range(2, max_level + 1):\n",
    "        water_mask = water_mask.Or(dswe.eq(level))\n",
    "\n",
    "    return water_mask.rename(['waterMask'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb34623b",
   "metadata": {},
   "source": [
    "## Initialize functions to curate Landsat imagery from GEE (collection 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b29b4ab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function _set_css_in_cell_output at 0x0000024A4DC6F600> (for pre_run_cell), with arguments args (<ExecutionInfo object at 24a4e26d810, raw_cell=\"def maskL8sr(image):\n",
      "    \"\"\"\n",
      "    Masks out clouds ..\" store_history=True silent=False shell_futures=True cell_id=None>,),kwargs {}:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "_set_css_in_cell_output() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;31mTypeError\u001b[0m: _set_css_in_cell_output() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "def maskL8sr(image):\n",
    "    \"\"\"\n",
    "    Masks out clouds and cloud shadows within Landsat 8 and 9 images using the BQA band.\n",
    "\n",
    "    Args:\n",
    "        image: ee.Image, the input Landsat image.\n",
    "\n",
    "    Returns:\n",
    "        ee.Image: The cloud-masked image.\n",
    "    \"\"\"\n",
    "    # Bit positions for cloud shadow (bit 3) and clouds (bit 5) in the QA_PIXEL band\n",
    "    cloud_shadow_bit_mask = (1 << 3)\n",
    "    clouds_bit_mask = (1 << 5)\n",
    "    # Select the BQA band\n",
    "    qa = image.select('BQA')\n",
    "    # Both bits should be zero for clear conditions\n",
    "    mask = qa.bitwiseAnd(cloud_shadow_bit_mask).eq(0).And(\n",
    "        qa.bitwiseAnd(clouds_bit_mask).eq(0)\n",
    "    )\n",
    "    return image.updateMask(mask)\n",
    "\n",
    "def getLandsatCollection():\n",
    "    \"\"\"\n",
    "    Merges Landsat 5, 7, 8, and 9 collections (Tier 1, Collection 2 SR) \n",
    "    and standardizes the band names for consistent analysis.\n",
    "\n",
    "    Returns:\n",
    "        ee.ImageCollection: A merged collection of standardized Landsat images.\n",
    "    \"\"\"\n",
    "    # Define the band mappings for each Landsat version\n",
    "    bn9 = ['SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7', 'QA_PIXEL']\n",
    "    bn8 = ['SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7', 'QA_PIXEL']\n",
    "    bn7 = ['SR_B1', 'SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B7', 'QA_PIXEL']\n",
    "    bn5 = ['SR_B1', 'SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B7', 'QA_PIXEL']\n",
    "    # Standardized names for all bands\n",
    "    standard_bands = ['uBlue', 'Blue', 'Green', 'Red', 'Nir', 'Swir1', 'Swir2', 'BQA']\n",
    "\n",
    "    # Fetch and rename bands in the Landsat collections\n",
    "    ls5 = ee.ImageCollection(\"LANDSAT/LT05/C02/T1_L2\").select(bn5, standard_bands)\n",
    "    ls7 = ee.ImageCollection(\"LANDSAT/LE07/C02/T1_L2\").filterDate('1999-04-15', '2003-05-30').select(bn7, standard_bands)\n",
    "    ls8 = ee.ImageCollection(\"LANDSAT/LC08/C02/T1_L2\").select(bn8, standard_bands)\n",
    "    ls9 = ee.ImageCollection(\"LANDSAT/LC09/C02/T1_L2\").select(bn9, standard_bands)\n",
    "\n",
    "    # Merge all collections\n",
    "    merged_collection = ls5.merge(ls7).merge(ls8).merge(ls9)\n",
    "\n",
    "    return merged_collection\n",
    "\n",
    "def rescale(image):\n",
    "    \"\"\"\n",
    "    Rescale the reflectance values of Landsat imagery to allow for use of Landsat Collection 2 in DSWE.\n",
    "\n",
    "    Parameters:\n",
    "    image (ee.Image): The input image with bands to be rescaled.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The image with rescaled bands added.\n",
    "    \"\"\"\n",
    "    bns = ['uBlue', 'Blue', 'Green', 'Red', 'Nir', 'Swir1', 'Swir2', 'BQA']\n",
    "    optical_bands = image.select(bns).multiply(0.0000275).add(-0.2)\n",
    "    return image.addBands(optical_bands, None, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8212f66",
   "metadata": {},
   "source": [
    "## Function to import study area polygon/s or reaches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eff4f80b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function _set_css_in_cell_output at 0x0000024A4DC6F600> (for pre_run_cell), with arguments args (<ExecutionInfo object at 24a4f9f5d50, raw_cell=\"def load_watershed_shapefile(folder_name, base_pat..\" store_history=True silent=False shell_futures=True cell_id=None>,),kwargs {}:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "_set_css_in_cell_output() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;31mTypeError\u001b[0m: _set_css_in_cell_output() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "def load_watershed_shapefile(folder_name, base_path):\n",
    "    \"\"\"\n",
    "    Loads a watershed shapefile or reach shapefile into an Earth Engine FeatureCollection.\n",
    "\n",
    "    Parameters:\n",
    "        - folder_name: str, the name of the specific watershed/reach folder/shapefile. This can include one or more features.\n",
    "        - base_path: str, optional base directory containing watershed folders (default set to your path).\n",
    "\n",
    "    Returns:\n",
    "        - ee.FeatureCollection: An Earth Engine FeatureCollection representing the watershed geometry.\n",
    "    \"\"\"\n",
    "    # Construct the full path to the shapefile\n",
    "    shapefile_path = os.path.join(base_path, folder_name, f\"{folder_name}.shp\")\n",
    "    \n",
    "    # Check if the shapefile exists\n",
    "    if not os.path.exists(shapefile_path):\n",
    "        print(f\"No shapefile found at {shapefile_path}\")\n",
    "        return None\n",
    "    \n",
    "    # Load the shapefile into a GeoDataFrame\n",
    "    try:\n",
    "        gdf = gpd.read_file(shapefile_path)\n",
    "    except Exception as e:\n",
    "        print(f\"Error loading shapefile: {e}\")\n",
    "        return None\n",
    "    \n",
    "    # Initialize the Earth Engine API if not already done\n",
    "    if not ee.data._credentials:\n",
    "        ee.Initialize()\n",
    "    \n",
    "    # Convert the GeoDataFrame to a GeoJSON-like structure and then to a FeatureCollection\n",
    "    try:\n",
    "        feature_collection = geemap.geopandas_to_ee(gdf)\n",
    "    except Exception as e:\n",
    "        print(f\"Error converting GeoDataFrame to FeatureCollection: {e}\")\n",
    "        return None\n",
    "\n",
    "    return feature_collection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47ea37e6",
   "metadata": {},
   "source": [
    "## Functions to generate DSWE water masks for the provided study/area or reaches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "af5b9f7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function _set_css_in_cell_output at 0x0000024A4DC6F600> (for pre_run_cell), with arguments args (<ExecutionInfo object at 24a4a1c8790, raw_cell=\"# Function to generate a water mask for a given ye..\" store_history=True silent=False shell_futures=True cell_id=None>,),kwargs {}:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "_set_css_in_cell_output() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;31mTypeError\u001b[0m: _set_css_in_cell_output() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "# Function to generate a water mask for a given year and polygon feature\n",
    "def get_water_mask_for_feature(year, max_level, polygon):\n",
    "    \"\"\"\n",
    "    Generate a water mask for a given year and polygon feature using Landsat imagery.\n",
    "\n",
    "    Parameters:\n",
    "    year (int): The year for which to generate the water mask.\n",
    "    max_level (float): The maximum DSWE water level threshold for classification.\n",
    "    polygon (ee.Geometry.Polygon): The polygon feature defining the area of interest.\n",
    "\n",
    "    Returns:\n",
    "    ee.Image: The water mask image for the specified year and polygon.\n",
    "    \"\"\"\n",
    "    imagery = (getLandsatCollection()\n",
    "               .map(maskL8sr)\n",
    "               .map(rescale)\n",
    "               .filterDate(f'{year}-01-01', f'{year}-12-31')\n",
    "               .filterBounds(polygon))\n",
    "\n",
    "    image_composite = imagery.median().clip(polygon)\n",
    "    water_mask = ClassifyWaterJones2019(image_composite, max_level)\n",
    "\n",
    "    return water_mask\n",
    "\n",
    "# Main function to generate water masks for each feature in a FeatureCollection\n",
    "def get_water_masks(year, folder_name, max_level, base_path=r'C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\Reaches'):\n",
    "    \"\"\"\n",
    "    Generate water masks for each feature in a FeatureCollection for a given year.\n",
    "\n",
    "    Parameters:\n",
    "    year (int): The year for which to generate the water masks.\n",
    "    folder_name (str): The name of the folder containing the study area shapefile.\n",
    "    max_level (float): The maximum DSWE water level threshold for classification.\n",
    "    base_path (str): The base path to the directory containing the study area shapefile.\n",
    "\n",
    "    Returns:\n",
    "    ee.FeatureCollection: A FeatureCollection with water masks for each feature.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Load study area shapefile, using the base path\n",
    "    polygon_fc = load_watershed_shapefile(folder_name, base_path)\n",
    "\n",
    "    # Map over each feature in the FeatureCollection and generate water masks\n",
    "    water_masks = polygon_fc.map(lambda feature: get_water_mask_for_feature(year, max_level, feature.geometry()).set('polygon_id', feature.id()))\n",
    "\n",
    "    return water_masks\n",
    "\n",
    "# Function to export masks for a range of years and features within a polygon feature collection\n",
    "def export_masks(folder_name, max_level, year_range=\"All\", reach_range=\"All\", \n",
    "                 base_path=r'C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\Reaches', \n",
    "                 local_output_path=r'C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks'):\n",
    "    \n",
    "    \"\"\"\n",
    "    Generates water masks for a given river and specified range of years and reaches.\n",
    "\n",
    "    Parameters:\n",
    "        year_range (str, int, tuple, optional): Range of years (start, end), a single year, or \"All\".\n",
    "        reach_range (str, int, tuple, optional): Range of reaches (start, end), a single reach, or \"All\".\n",
    "        folder_name (str): Name of the folder containing watershed shapefile.\n",
    "        max_level (int): Maximum DSWE level for water mask generation.\n",
    "        base_path (str, optional): Base path to the folder containing watershed shapefiles.\n",
    "        local_output_path (str, optional): Local path where the output masks will be saved.\n",
    "\n",
    "    Outputs:\n",
    "        Exports water masks as TIFF files to the specified local output path.\n",
    "    \"\"\"\n",
    "    # Load watershed shapefile\n",
    "    polygon_fc = load_watershed_shapefile(folder_name, base_path)\n",
    "        \n",
    "    # Define the target CRS\n",
    "    target_crs = 'EPSG:4326'\n",
    "        \n",
    "    # Determine the year range\n",
    "    if year_range == \"All\":\n",
    "        year_start = 1984\n",
    "        year_end = 2025\n",
    "    elif isinstance(year_range, int):\n",
    "        year_start = year_range\n",
    "        year_end = year_range\n",
    "    elif isinstance(year_range, tuple) and len(year_range) == 2:\n",
    "        year_start, year_end = year_range\n",
    "    else:\n",
    "        raise ValueError(\"year_range must be 'All', an int, or a tuple (start, end).\")\n",
    "        \n",
    "    # Determine the reach range\n",
    "    if reach_range == \"All\":\n",
    "        reach_start = 1\n",
    "        reach_end = 9999\n",
    "    elif isinstance(reach_range, int):\n",
    "        reach_start = reach_range\n",
    "        reach_end = reach_range\n",
    "    elif isinstance(reach_range, tuple) and len(reach_range) == 2:\n",
    "        reach_start, reach_end = reach_range\n",
    "    else:\n",
    "        raise ValueError(\"reach_range must be 'All', an int, or a tuple (start, end).\")\n",
    "        \n",
    "    for feature in polygon_fc.getInfo()['features']:\n",
    "            \n",
    "            # Get the geometry and ID of the feature\n",
    "            feature_geom = ee.Feature(feature).geometry()\n",
    "            feature_id = int(feature['properties']['ds_order'])\n",
    "                \n",
    "            # Check if the feature_id is within the reach range\n",
    "            if reach_start <= feature_id <= reach_end:\n",
    "                # Create the reach subfolder if it does not exist\n",
    "                reach_folder_path = os.path.join(local_output_path, folder_name, f\"reach_{feature_id}\")\n",
    "                if not os.path.exists(reach_folder_path):\n",
    "                    os.makedirs(reach_folder_path)\n",
    "                    \n",
    "                for year in range(year_start, year_end + 1):\n",
    "                    # Generate the water mask for the current year and feature\n",
    "                    water_mask = get_water_mask_for_feature(year, max_level, feature_geom)\n",
    "                        \n",
    "                    # Reproject the water mask to WGS 84\n",
    "                    water_mask_reprojected = water_mask.reproject(crs=target_crs, scale=30)\n",
    "                        \n",
    "                    # Set the output file path based on the folder, year, and feature ID\n",
    "                    output_file_name = f\"{folder_name}_reach_{feature_id}_{year}_DSWE_level_{max_level}.tif\"\n",
    "                    output_file_path = os.path.join(reach_folder_path, output_file_name)\n",
    "                        \n",
    "                    # Export the water mask to the local folder\n",
    "                    geemap.ee_export_image(\n",
    "                        water_mask_reprojected,\n",
    "                        filename=output_file_path,\n",
    "                        scale=30,\n",
    "                        region=feature_geom,\n",
    "                        file_per_band=False\n",
    "                    )\n",
    "                        \n",
    "                    print(f\"Exported {output_file_name} to {reach_folder_path}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f44cc925",
   "metadata": {},
   "source": [
    "## 7) Input parameters and generate masks, download to local folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9a16d629",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function _set_css_in_cell_output at 0x0000024A4DC6F600> (for pre_run_cell), with arguments args (<ExecutionInfo object at 24a4f8bebd0, raw_cell=\"# Required input variables\n",
      "# Name of river (must m..\" store_history=True silent=False shell_futures=True cell_id=None>,),kwargs {}:\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "_set_css_in_cell_output() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;31mTypeError\u001b[0m: _set_css_in_cell_output() takes 0 positional arguments but 1 was given"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/f32d8178c5b1bdadefec6a84fe419873-54807f2dde0b275754b272ea69fa85d7:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2015_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2015_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/f2d5306c970ffbf70a257331ed9dc6ff-5a18a4a784ee4203c9b037021ead9cc0:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2016_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2016_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/6cf00b2300b4b90fd521e8f972a2f4fa-04b74df04a083465e22a4ea114dd1576:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2017_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2017_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/40e11cfd826278a86fb41cb24b1b20bc-929f029bb620c58f0ddf28a5a402c99d:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2018_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2018_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/d702102dd648e8666ef3a8a3d88f6e68-15660f8e777389bc4cb77412b9fe337e:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2019_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2019_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/ec8fee8dc5f5665f5fa812592e7caa08-b7334838b7098f4daf36ae78e7c94795:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2020_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2020_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/7d547eeef6d44ac1bc1eb75214058b86-ecdd3ea3ab3c24fb72ed823d182a275d:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2021_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2021_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/1edf65965f0b74d01b127da809eb56b6-64c99beee75590c479131af4afa88b8d:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2022_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2022_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n",
      "Generating URL ...\n",
      "Downloading data from https://earthengine.googleapis.com/v1/projects/earthengine-legacy/thumbnails/c879386ab141e5cbacd275f76cf5e040-62033affe3a3263f27f012409c89c1b6:getPixels\n",
      "Please wait ...\n",
      "Data downloaded to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25\\Brahmaputra_reach_25_2023_DSWE_level_2.tif\n",
      "Exported Brahmaputra_reach_25_2023_DSWE_level_2.tif to C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks\\Brahmaputra\\reach_25.\n"
     ]
    }
   ],
   "source": [
    "# Required input variables\n",
    "# Name of river (must match folder name)\n",
    "Folder_name = 'Brahmaputra'\n",
    "\n",
    "# DSWE water masking threshold, can be between 1 and 4. 4 will mask the most water, but overestimate water coverage.\n",
    "# See Jones et al. (2019) for more info on DSWE water classes\n",
    "DSWE_threshold_level = 2\n",
    "\n",
    "# Specify the range in years to process. The user can enter either a range of years, a specific year, or \"All\" to process\n",
    "# all years for the given reach/reaches. Example inputs are (1997, 2017) for a range of years, 2017 for a single year, or \n",
    "# \"All\" for all years. \"All\" will result in the code attempting to process the years 1984 - 2025, the period of the Landsat\n",
    "# record plus some more.\n",
    "year_range = (2015, 2023)\n",
    "\n",
    "# Specify reach/reaches to process. The user can enter either a range of reaches, a single reach, or \"All\" to process all\n",
    "# reaches within the river reach shapefile. Example inputs are (1, 40) for a range of reaches, 8 for a single reach, or \n",
    "# \"All\" for all reaches\n",
    "reach_range = 25\n",
    "\n",
    "# Optional input variables\n",
    "base_path = r'C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\Reaches'\n",
    "local_output_path = r'C:\\Users\\huckr\\Desktop\\UCSB\\Dissertation\\Data\\RiverMapping\\RiverMasks'\n",
    "\n",
    "export_masks(Folder_name, \n",
    "             DSWE_threshold_level,\n",
    "             year_range, \n",
    "             reach_range, \n",
    "             base_path,\n",
    "             local_output_path\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebcbec1c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}