Validating rio-tiler's zonal statistics against a geographical coordinates method

rio_tiler_zonalstats_reader.py

"""
Adapted from the rio-tiler docs: https://cogeotiff.github.io/rio-tiler/advanced/statistics/#area-weighted-statistics
"""

import attr
from typing import Any, Union, Optional, List, Dict

from rio_tiler import io
from rio_tiler.models import BandStatistics
from rio_tiler.constants import WGS84_CRS

from rasterio.crs import CRS

from geojson_pydantic.features import Feature, FeatureCollection
from geojson_pydantic.geometries import Polygon


class Reader(io.Reader):
    """Custom Reader with zonal_statistics method."""

    def zonal_statistics(
        self,
        geojson: Union[FeatureCollection, Feature],
        categorical: bool = False,
        categories: Optional[List[float]] = None,
        percentiles: Optional[List[int]] = None,
        hist_options: Optional[Dict] = None,
        max_size: int = None,
        align_bounds_with_dataset: bool = True,
        shape_crs: Optional[CRS] = WGS84_CRS,
        cover_scale: int = 10,
        **kwargs: Any,
    ) -> Union[FeatureCollection, Feature]:
        """Return statistics from GeoJSON features.

        Args:
            geojson (Feature or FeatureCollection): a GeoJSON Feature or FeatureCollection.
            categorical (bool): treat input data as categorical data. Defaults to False.
            categories (list of numbers, optional): list of categories to return value for.
            percentiles (list of numbers, optional): list of percentile values to calculate. Defaults to `[2, 98]`.
            hist_options (dict, optional): Options to forward to numpy.histogram function.
            max_size (int, optional): Limit the size of the longest dimension of the dataset read, respecting bounds X/Y aspect ratio. Defaults to None.
            kwargs (optional): Options to forward to `self.feature`.

        Returns:
            Feature or FeatureCollection

        """
        kwargs = {**self.options, **kwargs}

        hist_options = hist_options or {}

        fc = geojson
        # We transform the input Feature to a FeatureCollection
        if isinstance(fc, Feature):
            fc = FeatureCollection(type="FeatureCollection", features=[geojson])

        for feature in fc:
            geom = feature.model_dump(exclude_none=True)

            # Get data overlapping with the feature (using Reader.feature method)
            data = self.feature(
                geom,
                shape_crs=shape_crs,
                align_bounds_with_dataset=align_bounds_with_dataset,
                max_size=max_size,
                **kwargs,
            )
            coverage_array = data.get_coverage_array(
                geom,
                shape_crs=shape_crs,
                cover_scale=cover_scale,
            )

            stats = data.statistics(
                categorical=categorical,
                categories=categories,
                percentiles=percentiles,
                hist_options=hist_options,
                coverage=coverage_array,
            )
            
            yield coverage_array, stats

            # Update input feature properties and add the statistics
            feature.properties = feature.properties or {}
            feature.properties.update({"statistics": stats})

        #return fc.features[0] if isinstance(geojson, Feature) else fcimport attr
from typing import Any, Union, Optional, List, Dict

from rio_tiler import io
from rio_tiler.models import BandStatistics
from rio_tiler.constants import WGS84_CRS

from geojson_pydantic.features import Feature, FeatureCollection
from geojson_pydantic.geometries import Polygon

zonal-statistics-validation-south-america-total-fluxes.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "---\n",
    "title: Validating rio-tiler's zonal statistics against a geographical coordinates method\n",
    "description: Calculating total carbon fluxes for South America\n",
    "authors: Sourish Basu & Jonas Sølvsteen\n",
    "published: 5 March 2024\n",
    "execute:\n",
    "   freeze: true\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Run this notebook\n",
    "\n",
    "You can launch this notebook in VEDA JupyterHub by clicking the link below.\n",
    "\n",
    "[Launch in VEDA JupyterHub (requires access)](https://hub.openveda.cloud/hub/user-redirect/git-pull?repo=https://github.com/NASA-IMPACT/veda-docs&urlpath=lab/tree/veda-docs/notebooks/tutorials/zonal-statistics-titiler-validation.ipynb&branch=main) \n",
    "\n",
    "<details><summary>Learn more</summary>\n",
    "    \n",
    "### Inside the Hub\n",
    "\n",
    "This notebook was written on the VEDA JupyterHub and as such is designed to be run on a jupyterhub which is associated with an AWS IAM role which has been granted permissions to the VEDA data store via its bucket policy. The instance used provided 16GB of RAM. \n",
    "\n",
    "See (VEDA Analytics JupyterHub Access)[https://nasa-impact.github.io/veda-docs/veda-jh-access.html] for information about how to gain access.\n",
    "\n",
    "### Outside the Hub\n",
    "\n",
    "The data is in a protected bucket. Please request access by emailng aimee@developmentseed.org or alexandra@developmentseed.org and providing your affiliation, interest in or expected use of the dataset and an AWS IAM role or user Amazon Resource Name (ARN). The team will help you configure the cognito client.\n",
    "\n",
    "You should then run:\n",
    "\n",
    "```\n",
    "%run -i 'cognito_login.py'\n",
    "```\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Approach\n",
    "\n",
    "### Motivation\n",
    "\n",
    "The VEDA backend (via TiTiler) provides an API endpoint for computing zonal statistics (average, standard deviation, and other metrics over a geographic subset) across gridded (raster) data such as satellite imagery or climate datasets.\n",
    "\n",
    "Some statistics, such as average, median, standard deviation, or percentiles are sensitive to differences in grid cell / pixel sizes: when some grid cells are (in metric units) have a larger area than others, the values in these cells will be under-represented. Grid cell sizes depends on the grid / projection of the data.\n",
    "\n",
    "Varying grid cell sizes is common for climate datasets that are stored on a grid in geographic coordinates (lat/lon), for example a 0.1 degree by 0.1 degree global grid. Here, grid cell size will decrease from low to high latitudes. Computing averages over large spans of latitude will result in statistics where values closer to the poles are strongly over-represented. \n",
    "\n",
    "To avoid this inaccuracy in zonal statistics computed with our API, we introduced a method to reproject the source data to an equal-area projection as an intermediate step in calculating statistics.\n",
    "\n",
    "Note: this reprojection is not needed for example for accurate zonal statistics on a Sentinel-2 scene, using the Military Grid Reference System (MGRS) and a Mercator (UTM) projection. Here, pixel areas are the same across the scene in the native projection.\n",
    "\n",
    "### In this notebook\n",
    "\n",
    "\n",
    "\n",
    "This notebook presents a validation of VEDA's API for zonal statistics against a known way to compute area-weighted averages for gridded datasets on a regular lat/lon grid.\n",
    "\n",
    "For illustration, we choose a real dataset from the VEDA data catalog and a subsetting area that spans a large latitude range.\n",
    "\n",
    "The figures below show the average calculated over that area of interest with the different methods, for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%pip install pystac_client rio_tiler geojson_pydantic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import tqdm\n",
    "import rasterio\n",
    "import xarray as xr\n",
    "import rioxarray\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from pystac_client import Client\n",
    "import rasterio.enums\n",
    "import rasterio.crs\n",
    "from geojson_pydantic.features import Feature\n",
    "\n",
    "# local module containing the rio-tiler interface\n",
    "from rio_tiler_zonalstats_reader import Reader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate totals using areas calculated from geographic coordinates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Formula for lat/lon grid cells that is correct, i.e., I *know* it works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def surfaceAreaGrid(**kwargs):\n",
    "    # There can be different ways of specifying a rectangular lat/lon grid, assume always degrees not radians\n",
    "    if 'lat_edges' in kwargs: # boundaries, do not assume uniform spacing, but assume monotonically increasing\n",
    "        lat_edges = (np.pi/180.) * kwargs['lat_edges']\n",
    "    elif 'lat_centers' in kwargs: # centers, assume uniform spacing and monotonically increasing\n",
    "        lat_centers = kwargs['lat_centers']\n",
    "        dlat = np.diff(lat_centers).mean()\n",
    "        lat_edges = np.zeros(len(lat_centers)+1, dtype=np.float64)\n",
    "        lat_edges[0] = lat_centers[0]-0.5*dlat\n",
    "        lat_edges[1:] = lat_centers + 0.5*dlat\n",
    "        lat_edges = (np.pi/180.0) * lat_edges\n",
    "    else:\n",
    "        lat_min = kwargs['lat_min'] if 'lat_min' in kwargs else -90.0\n",
    "        lat_max = kwargs['lat_max'] if 'lat_max' in kwargs else 90.0\n",
    "        try:\n",
    "            nlat = kwargs['nlat']\n",
    "        except:\n",
    "            print('At least specify the number of divisions of latitude')\n",
    "            raise\n",
    "        lat_edges = (np.pi/180.) * np.linspace(lat_min, lat_max, nlat+1)\n",
    "\n",
    "    # now the longitude grid\n",
    "    if 'lon_edges' in kwargs: # boundaries, do not assume uniform spacing, but assume monotonically increasing\n",
    "        lon_edges = (np.pi/180.) * kwargs['lon_edges']\n",
    "    elif 'lon_centers' in kwargs: # centers, assume uniform spacing and monotonically increasing\n",
    "        lon_centers = kwargs['lon_centers']\n",
    "        dlon = np.diff(lon_centers).mean()\n",
    "        lon_edges = np.zeros(len(lon_centers)+1, dtype=np.float64)\n",
    "        lon_edges[0] = lon_centers[0]-0.5*dlon\n",
    "        lon_edges[1:] = lon_centers + 0.5*dlon\n",
    "        lon_edges = (np.pi/180.0) * lon_edges\n",
    "    else:\n",
    "        lon_min = kwargs['lon_min'] if 'lon_min' in kwargs else -180.0\n",
    "        lon_max = kwargs['lon_max'] if 'lon_max' in kwargs else 180.0\n",
    "        try:\n",
    "            nlon = kwargs['nlon']\n",
    "        except:\n",
    "            print('At least specify the number of divisions of longitude')\n",
    "            raise\n",
    "        lon_edges = (np.pi/180.) * np.linspace(lon_min, lon_max, nlon+1)\n",
    "\n",
    "    assert np.all(np.diff(lat_edges) > 0.0), \"Latitude edges must be monotonically increasing\"\n",
    "    assert np.all(np.diff(lon_edges) > 0.0), \"Longitude edges must be monotonically increasing\"\n",
    "    # Construct empty array of the right size that will later hold the grid areas\n",
    "    # We'll construct an array of dLon * sin(lat) for each latitude, then take the difference between\n",
    "    # successive rows later. Hence now the array will have one extra row.\n",
    "    dS = np.zeros((len(lat_edges), len(lon_edges)-1), np.float64)\n",
    "    dlon = np.diff(lon_edges) # a vector, could all be identical if lon spacing is uniform\n",
    "    for i, lat in enumerate(lat_edges):\n",
    "        dS[i] = dlon * np.sin(lat)\n",
    "    dS = np.diff(dS, axis=0)\n",
    "    \n",
    "    ret_area = kwargs['ret_area'] if 'ret_area' in kwargs else True # whether to return surface are or solid angle\n",
    "    if ret_area:\n",
    "        R_e = 6371000.0 # Radius of Earth in meters, as used by TM5 and GEOS\n",
    "        dS = R_e * R_e * dS\n",
    "\n",
    "    return dS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6) 1.0\n",
      "(2, 3) 1.0\n",
      "(90, 180) 0.24999999999999997\n",
      "6370999.999999999\n"
     ]
    }
   ],
   "source": [
    "# try the function out\n",
    "lat_edges = np.array([-90., -70., 0., 30., 45., 90.])\n",
    "lon_edges = np.array([-180., -90., 30., 35., 80., 120., 180.])\n",
    "dS = surfaceAreaGrid(lat_edges=lat_edges, lon_edges=lon_edges)\n",
    "print(dS.shape, dS.sum()/4./np.pi/6371000/6371000)\n",
    "dS = surfaceAreaGrid(nlat=2, nlon=3, ret_area=False)\n",
    "print(dS.shape, dS.sum()/4./np.pi)\n",
    "lat_centers = np.linspace(0.5,89.5,90)\n",
    "lon_centers = np.linspace(-89.5,89.5,180)\n",
    "dS = surfaceAreaGrid(lat_centers=lat_centers, lon_centers=lon_centers, ret_area=False)\n",
    "print(dS.shape, dS.sum()/4./np.pi) # should be quarter the earth's surface\n",
    "dS = surfaceAreaGrid(lat_centers=np.arange(-89.75, 90., 0.5), lon_centers=np.arange(-179.75,180., 0.5), ret_area=True)\n",
    "print(np.sqrt(dS.sum()/4./np.pi)) # should be the radius of the Earth in meters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code to read NPP from the cloud\n",
    "from pystac_client import Client\n",
    "import xarray as xr\n",
    "import rioxarray\n",
    "\n",
    "STAC_API_URL = \"http://ghg.center/api/stac\"\n",
    "COLLECTION_ID = \"casagfed-carbonflux-monthgrid-v3\"\n",
    "ASSET_NAME = \"npp\"\n",
    "catalog = Client.open(STAC_API_URL)\n",
    "collection = catalog.get_collection(COLLECTION_ID)\n",
    "items = list(collection.get_all_items())[:15] # each element is a month\n",
    "item = items[0] # one month\n",
    "item_uri = item.assets[ASSET_NAME].href\n",
    "with xr.open_dataset(item_uri, engine=\"rasterio\") as xds:\n",
    "    latitudes = xds.y.values\n",
    "    longitudes = xds.x.values\n",
    "    npp = xds.band_data.values[0]\n",
    "# Since latitudes are north to south, flip\n",
    "latitudes = latitudes[::-1]\n",
    "npp = npp[::-1,:] # kg/m^2/month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "142 152\n"
     ]
    }
   ],
   "source": [
    "# define lat/lon box for South America and subselect\n",
    "lat_bounds = (-57., 14.)\n",
    "lon_bounds = (-83., -7.)\n",
    "lat_idx = np.logical_and(latitudes > lat_bounds[0], latitudes < lat_bounds[1])\n",
    "lon_idx = np.logical_and(longitudes > lon_bounds[0], longitudes < lon_bounds[1])\n",
    "# check\n",
    "print(lat_idx.sum(), lon_idx.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(360, 720)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(142, 152)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(npp.shape)\n",
    "(npp[lat_idx][:,lon_idx]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total NPP for this month is 1675.5513 Tg\n"
     ]
    }
   ],
   "source": [
    "# get area array\n",
    "dS = surfaceAreaGrid(lat_centers=latitudes[lat_idx], lon_centers=longitudes[lon_idx], ret_area=True)\n",
    "# calculate flux total\n",
    "flux_total = (npp[lat_idx][:,lon_idx] * dS).sum() * 1.0E-9 # Tg/month\n",
    "print(\"Total NPP for this month is %.4f Tg\"%flux_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Calculating NPP totals over S America: 100%|██████████| 15/15 [00:05<00:00,  2.84it/s]\n"
     ]
    }
   ],
   "source": [
    "# Now do this for all months\n",
    "flux_totals = []\n",
    "dS = None\n",
    "for item in tqdm.tqdm(items, desc='Calculating NPP totals over S America'):\n",
    "    item_uri = item.assets[ASSET_NAME].href\n",
    "    with xr.open_dataset(item_uri, engine=\"rasterio\") as xds:\n",
    "        latitudes = xds.y.values\n",
    "        longitudes = xds.x.values\n",
    "        npp = xds.band_data.values[0]\n",
    "    latitudes = latitudes[::-1]\n",
    "    npp = npp[::-1,:] # kg/m^2/month\n",
    "    lat_idx = np.logical_and(latitudes > lat_bounds[0], latitudes < lat_bounds[1])\n",
    "    lon_idx = np.logical_and(longitudes > lon_bounds[0], longitudes < lon_bounds[1])\n",
    "    dS = surfaceAreaGrid(lat_centers=latitudes[lat_idx], lon_centers=longitudes[lon_idx], ret_area=True) # don't need to do this for each item, lazy...\n",
    "    flux_total = (npp[lat_idx][:,lon_idx] * dS).sum() * 1.0E-12 # Pg/month\n",
    "    flux_totals.append(flux_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'NPP over S America (Pg/month)')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the totals\n",
    "from matplotlib import pyplot as plt\n",
    "plt.plot(flux_totals, '-bo', lw=2)\n",
    "plt.xlabel('Month (0-14, first 15 months)')\n",
    "plt.ylabel('NPP over S America (Pg/month)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# End of code from So"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate totals with rio-tiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6.4.4'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import rio_tiler\n",
    "rio_tiler.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create GeoJSON polygon from lat/lon bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "south, north = lat_bounds\n",
    "west, east = lon_bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "geojson = {\n",
    "    \"type\": \"Feature\",\n",
    "    \"properties\": {},\n",
    "    \"geometry\": {\n",
    "        \"type\": \"Polygon\",\n",
    "        \"coordinates\": [\n",
    "            [\n",
    "                [west, north],\n",
    "                [east, north],\n",
    "                [east, south],\n",
    "                [west, south],\n",
    "                [west, north]\n",
    "            ]\n",
    "        ]\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature = Feature(**geojson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: rio-tiler only calculates averages, not totals (scaled by cell area). \n",
    "\n",
    "To make the results comparable, we will scale the rio-tiler averages with the total area computed above from geographic coordinates, to get the total flux.\n",
    "\n",
    "This does introduce an inaccuracy, since the total area in the equal-area reprojected data may not be identical to that in geographic coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "TOTAL_AREA = dS.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate totals for all time steps\n",
    "\n",
    "With and without reprojection to an equal-area projection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "CRS_CEA = rasterio.crs.CRS.from_proj4(\"+proj=cea\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Calculating NPP totals over S America: 100%|██████████| 15/15 [00:04<00:00,  3.25it/s]\n"
     ]
    }
   ],
   "source": [
    "flux_totals_rio = []\n",
    "flux_totals_rio_noea = []\n",
    "\n",
    "for item in tqdm.tqdm(items, desc='Calculating NPP totals over S America'):\n",
    "    reader = Reader(item.assets[ASSET_NAME].href)\n",
    "    \n",
    "    _, stats = next(reader.zonal_statistics(\n",
    "        feature,\n",
    "        align_bounds_with_dataset=True,\n",
    "        shape_crs=reader.crs,\n",
    "        cover_scale=10,\n",
    "        dst_crs=CRS_CEA,\n",
    "        vrt_options={\"resampling\": rasterio.enums.Resampling.bilinear}\n",
    "    ))\n",
    "    flux_totals_rio.append(stats[\"b1\"].mean * TOTAL_AREA * 1.0E-12) # Pg/month\n",
    "\n",
    "    _, stats = next(reader.zonal_statistics(\n",
    "        feature,\n",
    "        align_bounds_with_dataset=False,\n",
    "        shape_crs=reader.crs,\n",
    "        cover_scale=10,\n",
    "        #dst_crs=CRS_CEA,\n",
    "        #vrt_options={\"resampling\": rasterio.enums.Resampling.bilinear}\n",
    "    ))\n",
    "    flux_totals_rio_noea.append(stats[\"b1\"].mean * TOTAL_AREA * 1.0E-12) # Pg/month"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare results between geographical coordinates method and rio-tiler\n",
    "\n",
    "For rio-tiler, we also show the difference it makes to reproject the data to an equal-area projection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the totals\n",
    "from matplotlib import pyplot as plt\n",
    "plt.plot(flux_totals, '-bo', lw=2, label=\"Sourish\")\n",
    "plt.plot(flux_totals_rio, ':ro', lw=2, label=\"rio-tiler w/ equal-area\")\n",
    "plt.plot(flux_totals_rio_noea, ls='-', marker=\"o\", color=\"grey\", lw=2, label=\"rio-tiler w/o equal-area\")\n",
    "plt.xlabel('Month (0-14, first 15 months)')\n",
    "plt.ylabel('NPP over S America (Pg/month)')\n",
    "plt.legend() ;"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}