From 0264a4e59a96a120e1f42c7b4bc2b432a6921ab6 Mon Sep 17 00:00:00 2001 From: madhuksridhar Date: Fri, 15 Nov 2024 11:20:52 -0600 Subject: [PATCH] add testing notebook to compare VI raster with manual calculation --- tests/HLS-VI-verification.ipynb | 666 ++++++++++++++++++++++++++++++++ 1 file changed, 666 insertions(+) create mode 100644 tests/HLS-VI-verification.ipynb diff --git a/tests/HLS-VI-verification.ipynb b/tests/HLS-VI-verification.ipynb new file mode 100644 index 0000000..7e96d7a --- /dev/null +++ b/tests/HLS-VI-verification.ipynb @@ -0,0 +1,666 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d04932cd", + "metadata": {}, + "source": [ + "## HLS-VI testing notebook\n", + "This notebook compares the generated HLS-VI raster data with manually calculated indices.\n", + "Nine indices that are part of HLS-VI granule are NDVI, NDWI,NDMI, NBR, NBR2, TVI, EVI, SAVI, MSAVI\n", + "\n", + "### Notes:\n", + "NDVI, NDWI,NDMI, NBR, NBR2, EVI, SAVI, MSAVI have a scaling factor of 10,000 but TVI has a scaling factor of 100.\n", + "\n", + "To open the tif files, while many option exist, we are using `rasterio.open()` to be consistent with the `generate_indices.py` script. At the end of the notebook, a few other options to read the data is verified for a single pixel. But note that there can be subtle differences depending on the utility used for opening the rasters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "592a8002", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xr\n", + "import rioxarray as rxr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import rasterio" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "05f15252", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "S30\n" + ] + } + ], + "source": [ + "# define path to tif file\n", + "dir_path = \"/Users/sridhar22-mbp/Downloads/\"\n", + "\n", + "hls_granule_id = \"HLS.S30.T14SMH.2024290T173321.v2.0\"\n", + "vi_granule_id = \"HLS-VI.S30.T14SMH.2024290T173321.v2.0\"\n", + "\n", + "sat_id = hls_granule_id.split(\".\")[1]\n", + "print(sat_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e0e07c02", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'B02': 'B', 'B03': 'G', 'B04': 'R', 'B05': 'NIR', 'B06': 'SWIR1', 'B07': 'SWIR2', 'Fmask': 'Fmask'}\n", + "{'B02': 'B', 'B03': 'G', 'B04': 'R', 'B8A': 'NIR', 'B11': 'SWIR1', 'B12': 'SWIR2', 'Fmask': 'Fmask'}\n" + ] + } + ], + "source": [ + "# Map Spectral Bands\n", + "# ignore Coastal aerosol and Cirrus bands\n", + "sr_bands_l30 = ['B02','B03','B04','B05','B06','B07', 'Fmask', '']\n", + "sr_bands_s30 = ['B02','B03','B04','B8A','B11','B12', 'Fmask', '']\n", + "common_bands = [\"B\",\"G\",\"R\",\"NIR\",\"SWIR1\", \"SWIR2\", 'Fmask']\n", + "\n", + "sr_bands_common_l30 = dict(zip(sr_bands_l30, common_bands))\n", + "sr_bands_common_s30 = dict(zip(sr_bands_s30, common_bands))\n", + "\n", + "print(sr_bands_common_l30)\n", + "print(sr_bands_common_s30)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a21f0820", + "metadata": {}, + "outputs": [], + "source": [ + "def open_file(base, band, band_name):\n", + " ## Open raster and apply scale and offset\n", + " fname = f\"{base}.{band}.tif\"\n", + " print(f\"Reading {fname}\") \n", + " \n", + " if band in [\"Fmask\"]:\n", + " scale_factor = 1\n", + " elif band in [\"TVI\"]:\n", + " scale_factor = 100 ## TVI scale factor \n", + " else:\n", + " scale_factor = 10_000\n", + " \n", + " try:\n", + " #da = rxr.open_rasterio(fname, mask_and_scale=True)\n", + " ## not using xarray here on purpose and keeping reading the tif using rasterio\n", + " ## to keep it consistent with generate_indices.py\n", + " with rasterio.open(fname) as tif:\n", + " data = tif.read(1, masked=True, fill_value=-9999) / scale_factor\n", + " \n", + " except FileNotFoundError:\n", + " print(\"There is no file \", fname)\n", + " \n", + " ## covert to xarray data array\n", + " da = xr.DataArray(data)\n", + " da.name = band_name\n", + " return da" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e92eb157", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Reading S30 raster data\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B02.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B03.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B04.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B8A.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B11.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.B12.tif\n", + "Reading /Users/sridhar22-mbp/Downloads/HLS.S30.T14SMH.2024290T173321.v2.0/HLS.S30.T14SMH.2024290T173321.v2.0.Fmask.tif\n" + ] + } + ], + "source": [ + "## Read HLS granule\n", + "sr_key = f\"{dir_path}{hls_granule_id}/{hls_granule_id}\" \n", + "\n", + "if sat_id == 'L30':\n", + " print(\"Reading L30 raster data\")\n", + " sr_das = [open_file(sr_key, band, band_name) for (band,band_name) in zip(sr_bands_l30, common_bands)]\n", + " sr_ds = xr.merge(sr_das, combine_attrs=\"drop_conflicts\") \n", + "elif sat_id == 'S30':\n", + " print(\"\\nReading S30 raster data\")\n", + " sr_das = [open_file(sr_key, band, band_name) for (band,band_name) in zip(sr_bands_s30, common_bands)]\n", + " sr_ds = xr.merge(sr_das, combine_attrs=\"drop_conflicts\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "928aa834", + "metadata": {}, + "outputs": [], + "source": [ + "red = sr_ds[\"R\"].round(4)\n", + "blue = sr_ds[\"B\"].round(4)\n", + "green = sr_ds[\"G\"].round(4)\n", + "nir = sr_ds[\"NIR\"].round(4)\n", + "swir1 = sr_ds[\"SWIR1\"].round(4)\n", + "swir2 = sr_ds[\"SWIR2\"].round(4)\n", + "fmask = sr_ds[\"Fmask\"].round(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3ad14ab1", + "metadata": {}, + "outputs": [], + "source": [ + "## NOTE: to get matching results, num_dec must be 2 for TVI\n", + "## number of decimal places to round\n", + "\n", + "num_dec = 4 \n", + "num_dec_tvi = 2 ## use fewer decimal places for TVI\n", + "\n", + "def calc_ndvi(red, nir):\n", + " NDVI_calc = (nir - red)/(nir + red)\n", + " return np.round(NDVI_calc,num_dec)\n", + "\n", + "def calc_ndwi(green, nir):\n", + " NDWI_calc = (green - nir)/(green + nir)\n", + " return np.round(NDWI_calc,num_dec)\n", + "\n", + "def calc_ndmi(swir1, nir):\n", + " NDMI_calc = (nir - swir1)/(nir + swir1)\n", + " return np.round(NDMI_calc,num_dec)\n", + "\n", + "def calc_nbr(swir2, nir):\n", + " NBR_calc = (nir - swir2)/(nir + swir2)\n", + " return np.round(NBR_calc,num_dec)\n", + "\n", + "def calc_nbr2(swir2, swir1):\n", + " NBR2_calc = (swir1 - swir2)/(swir1 + swir2)\n", + " return np.round(NBR2_calc,num_dec)\n", + " \n", + "def calc_evi(nir, red, blue):\n", + " EVI_calc = 2.5*(nir - red)/ (nir + 6*red -7.5*blue +1)\n", + " return np.round(EVI_calc,num_dec)\n", + " \n", + "def calc_msavi(nir, red):\n", + " MSAVI_calc= (2 * nir + 1 - np.sqrt((2 * nir + 1)**2 - 8 * (nir - red))) / 2\n", + " return np.round(MSAVI_calc,num_dec)\n", + "\n", + "def calc_tvi(nir, green):\n", + " TVI_calc = (120*(nir - green) - 200*(red - green ))/2\n", + " return np.round(TVI_calc,num_dec_tvi)\n", + "\n", + "def calc_savi(nir, red): \n", + " SAVI_calc = 1.5*(nir - red) / (nir + red + 0.5)\n", + " return np.round(SAVI_calc,num_dec)\n", + "\n", + "\n", + "NDVI_calc = calc_ndvi(red, nir)\n", + "NDWI_calc = calc_ndwi(green, nir)\n", + "NDMI_calc = calc_ndmi(swir1, nir)\n", + "NBR_calc = calc_nbr(swir2, nir)\n", + "NBR2_calc = calc_nbr2(swir2, swir1)\n", + "EVI_calc = calc_evi(nir, red, blue)\n", + "MSAVI_calc= calc_msavi(nir, red)\n", + "TVI_calc = calc_tvi(nir, green)\n", + "SAVI_calc = calc_savi(nir, red)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "51cfa8d0", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading VI raster data\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.NDVI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.NDWI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.NDMI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.NBR.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.NBR2.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.EVI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.MSAVI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.TVI.tif\n", + "Reading /Users/sridhar22-mbp/Downloads//HLS-VI.S30.T14SMH.2024290T173321.v2.0/HLS-VI.S30.T14SMH.2024290T173321.v2.0.SAVI.tif\n" + ] + } + ], + "source": [ + "# Read VI granule\n", + "sr_bands_vi = ['NDVI','NDWI','NDMI','NBR','NBR2','EVI', 'MSAVI', 'TVI', 'SAVI']\n", + "sr_key_vi = f\"{dir_path}/{vi_granule_id}/{vi_granule_id}\" \n", + "\n", + "print(f\"Reading VI raster data\")\n", + "sr_das_vi = [open_file(sr_key_vi, band, band) for (band) in sr_bands_vi]\n", + "sr_ds_vi = xr.merge(sr_das_vi, combine_attrs=\"drop_conflicts\") " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3605acbf", + "metadata": {}, + "outputs": [], + "source": [ + "## Round dataarrays to 4 decimal places\n", + "NDVI_ref = sr_ds_vi[\"NDVI\"].round(decimals = 4)\n", + "NDWI_ref = sr_ds_vi[\"NDWI\"].round(decimals = 4)\n", + "NDMI_ref = sr_ds_vi[\"NDMI\"].round(decimals = 4)\n", + "NBR_ref = sr_ds_vi[\"NBR\"].round(decimals = 4)\n", + "NBR2_ref = sr_ds_vi[\"NBR2\"].round(decimals = 4)\n", + "EVI_ref = sr_ds_vi[\"EVI\"].round(decimals = 4)\n", + "MSAVI_ref= sr_ds_vi[\"MSAVI\"].round(decimals = 4)\n", + "TVI_ref = sr_ds_vi[\"TVI\"].round(decimals = 4)\n", + "SAVI_ref = sr_ds_vi[\"SAVI\"].round(decimals = 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fb58402e", + "metadata": {}, + "outputs": [], + "source": [ + "def calc_per_diff(calc_data, ref_data):\n", + " ### Percentage difference \n", + " return 100*(ref_data - calc_data) / ref_data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b04e4936", + "metadata": {}, + "outputs": [], + "source": [ + "## consider only the clean pixels filtered using Fmask layer\n", + "clean_bits = {64, 128}\n", + "fmask_array = sr_ds[['Fmask']].squeeze().to_array()\n", + "\n", + "# Create the clean mask\n", + "clean_mask = fmask_array.isin(list(clean_bits))\n", + "\n", + "def get_clean_data(data, mask):\n", + " masked_raster = data.where(clean_mask==True)\n", + " return masked_raster\n", + "\n", + "masked_raster_ndvi_calc = get_clean_data(NDVI_calc, clean_mask)\n", + "masked_raster_ndwi_calc = get_clean_data(NDWI_calc, clean_mask)\n", + "masked_raster_ndmi_calc = get_clean_data(NDMI_calc, clean_mask)\n", + "masked_raster_nbr_calc = get_clean_data(NBR_calc, clean_mask)\n", + "masked_raster_nbr2_calc = get_clean_data(NBR2_calc, clean_mask)\n", + "masked_raster_evi_calc = get_clean_data(EVI_calc, clean_mask)\n", + "masked_raster_msavi_calc= get_clean_data(MSAVI_calc, clean_mask)\n", + "masked_raster_tvi_calc = get_clean_data(TVI_calc, clean_mask)\n", + "masked_raster_savi_calc = get_clean_data(SAVI_calc, clean_mask)\n", + "\n", + "masked_raster_ndvi_ref = sr_das_vi[0].where(clean_mask==True)\n", + "masked_raster_ndwi_ref = sr_das_vi[1].where(clean_mask==True)\n", + "masked_raster_ndmi_ref = sr_das_vi[2].where(clean_mask==True)\n", + "masked_raster_nbr_ref = sr_das_vi[3].where(clean_mask==True)\n", + "masked_raster_nbr2_ref = sr_das_vi[4].where(clean_mask==True)\n", + "masked_raster_evi_ref = sr_das_vi[5].where(clean_mask==True)\n", + "masked_raster_msavi_ref= sr_das_vi[6].where(clean_mask==True)\n", + "masked_raster_tvi_ref = sr_das_vi[7].where(clean_mask==True)\n", + "masked_raster_savi_ref = sr_das_vi[8].where(clean_mask==True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "537fdbd8", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "#percent diff for masked raster\n", + "ndvi_perdiff = calc_per_diff(masked_raster_ndvi_calc, masked_raster_ndvi_ref)\n", + "ndwi_perdiff = calc_per_diff(masked_raster_ndwi_calc, masked_raster_ndwi_ref)\n", + "ndmi_perdiff = calc_per_diff(masked_raster_ndmi_calc, masked_raster_ndmi_ref)\n", + "nbr_perdiff = calc_per_diff(masked_raster_nbr_calc, masked_raster_nbr_ref)\n", + "nbr2_perdiff = calc_per_diff(masked_raster_nbr2_calc, masked_raster_nbr2_ref)\n", + "evi_perdiff = calc_per_diff(masked_raster_evi_calc, masked_raster_evi_ref)\n", + "msavi_perdiff = calc_per_diff(masked_raster_msavi_calc, masked_raster_msavi_ref)\n", + "tvi_perdiff = calc_per_diff(masked_raster_tvi_calc, masked_raster_tvi_ref)\n", + "savi_perdiff = calc_per_diff(masked_raster_savi_calc, masked_raster_savi_ref)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "01ca2d38", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NDVI Top five pixels with difference of +/- 0.1%\n", + "Calc: []\n", + "Raster: []\n", + "Diff: []\n", + "Num of pixels with Diff: 0\n", + "Allclose: True\n", + "\n", + "NDWI Top five pixels with difference of +/- 0.1%\n", + "Calc: []\n", + "Raster: []\n", + "Diff: []\n", + "Num of pixels with Diff: 0\n", + "Allclose: True\n", + "\n", + "NDMI Top five pixels with difference of +/- 0.1%\n", + "Calc: [-0.0563 -0.0563 -0.0563]\n", + "Raster: [-0.0562 -0.0562 -0.0562]\n", + "Diff: [-0.0001 -0.0001 -0.0001]\n", + "Num of pixels with Diff: 3\n", + "Allclose: False\n", + "\n", + "TVI Top five pixels with difference of +/- 0.1%\n", + "Calc: []\n", + "Raster: []\n", + "Diff: []\n", + "Num of pixels with Diff: 0\n", + "Allclose: True\n", + "\n", + "NBR Top five pixels with difference of +/- 0.1%\n", + "Calc: [0.0438 0.0563 0.0563 0.0563 0.0563]\n", + "Raster: [0.0437 0.0562 0.0562 0.0562 0.0562]\n", + "Diff: [1.e-04 1.e-04 1.e-04 1.e-04 1.e-04]\n", + "Num of pixels with Diff: 7\n", + "Allclose: False\n", + "\n", + "NBR2 Top five pixels with difference of +/- 0.1%\n", + "Calc: [0.0693 0.0568 0.0863 0.0863]\n", + "Raster: [0.0692 0.0567 0.0862 0.0862]\n", + "Diff: [0.0001 0.0001 0.0001 0.0001]\n", + "Num of pixels with Diff: 4\n", + "Allclose: False\n", + "\n", + "SAVI Top five pixels with difference of +/- 0.1%\n", + "Calc: []\n", + "Raster: []\n", + "Diff: []\n", + "Num of pixels with Diff: 0\n", + "Allclose: True\n", + "\n", + "MSAVI Top five pixels with difference of +/- 0.1%\n", + "Calc: []\n", + "Raster: []\n", + "Diff: []\n", + "Num of pixels with Diff: 0\n", + "Allclose: True\n", + "\n" + ] + } + ], + "source": [ + "#Define threshold to check for differences\n", + "t = 0.1 # percent\n", + "\n", + "def print_differences(calc, ref, perdiff, t, index):\n", + " # get pixels with +/- t % difference\n", + " calc_bad = calc.where((perdiff>t) | (perdiff<-t)).values.ravel()\n", + " calc_notnan = calc_bad[~np.isnan(calc_bad)]\n", + "\n", + " ref_bad = ref.where((perdiff>t) | (perdiff<-t)).values.ravel()\n", + " ref_notnan = ref_bad[~np.isnan(ref_bad)]\n", + " \n", + " allclose = np.allclose(calc_notnan, ref_notnan) ## default tolerance\n", + " diff = np.subtract(calc_notnan, ref_notnan)\n", + " diff_idx = np.argsort(diff)\n", + "\n", + " \n", + " print(f\"{index} Top five pixels with difference of +/- {t}%\")\n", + " print(f\"Calc: {calc_notnan[diff_idx][-5:]}\") # print 5 worse pixel values \n", + " print(f\"Raster: {ref_notnan[diff_idx][-5:]}\") # print 5 worse pixel values \n", + " print(f\"Diff: {diff[diff_idx][-5:]}\")\n", + " print(f\"Num of pixels with Diff: {len(diff)}\")\n", + " print(f\"Allclose: {allclose}\")\n", + " print()\n", + " \n", + "print_differences(masked_raster_ndvi_calc, masked_raster_ndvi_ref, ndvi_perdiff, t, \"NDVI\") \n", + "print_differences(masked_raster_ndwi_calc, masked_raster_ndwi_ref, ndwi_perdiff, t, \"NDWI\") \n", + "print_differences(masked_raster_ndmi_calc, masked_raster_ndmi_ref, ndmi_perdiff, t, \"NDMI\") \n", + "print_differences(masked_raster_tvi_calc, masked_raster_tvi_ref, tvi_perdiff, t, \"TVI\") \n", + "print_differences(masked_raster_nbr_calc, masked_raster_nbr_ref, nbr_perdiff, t, \"NBR\") \n", + "print_differences(masked_raster_nbr2_calc, masked_raster_nbr2_ref, nbr2_perdiff, t, \"NBR2\") \n", + "print_differences(masked_raster_savi_calc, masked_raster_savi_ref, savi_perdiff, t, \"SAVI\") \n", + "print_differences(masked_raster_msavi_calc, masked_raster_msavi_ref, msavi_perdiff, t, \"MSAVI\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5392982d", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/nb/zbf9tcqj0194rts9b7nc7sqm0000gp/T/ipykernel_32307/1656304672.py:15: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cmap=plt.cm.get_cmap('tab20b', 2))\n", + "/var/folders/nb/zbf9tcqj0194rts9b7nc7sqm0000gp/T/ipykernel_32307/1656304672.py:6: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cmap=plt.cm.get_cmap('tab20b', 20))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " NDVI %DIFF Max: 0.0, Min: -0.04625346901017067\n", + " NDWI %DIFF Max: -0.0, Min: -0.0316255534471994\n", + " NDMI %DIFF Max: -0.0, Min: -0.1779359430605033\n", + " NBR %DIFF Max: 0.0, Min: -0.22883295194507075\n", + " NBR2 %DIFF Max: 0.0, Min: -0.17636684303351474\n", + " EVI %DIFF Max: 0.0, Min: -0.07082152974505436\n", + " msavi %DIFF Max: 0.0, Min: 0.0\n", + " tvi %DIFF Max: 0.0, Min: 0.0\n", + " SAVI %DIFF Max: 0.0, Min: -0.09328358208955491\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "fig, ax = plt.subplots(6,2, figsize=(10, 20))\n", + "\n", + "def plot_raster(data, fig, ax, title):\n", + " im = ax.imshow(data.squeeze(),\n", + " cmap=plt.cm.get_cmap('tab20b', 20))\n", + " fig.colorbar(im, label='% diff')\n", + " print(f\" {title} Max: {np.nanmax(data)}, Min: {np.nanmin(data)}\")\n", + "\n", + "# RGB\n", + "# sr_ds[['R','G','B']].squeeze().to_array().plot.imshow(ax=ax[0,0], robust=True)\n", + "\n", + "# Clean pixel mask\n", + "im1 = ax[0,1].imshow(clean_mask.squeeze(),\n", + " cmap=plt.cm.get_cmap('tab20b', 2))\n", + "ax[0,1].set_title(\"Clean pixel mask\")\n", + "\n", + "plot_raster(ndvi_perdiff, fig, ax[1,0], \"NDVI %DIFF\")\n", + "plot_raster(ndwi_perdiff, fig, ax[1,1], \"NDWI %DIFF\")\n", + "plot_raster(ndmi_perdiff, fig, ax[2,0], \"NDMI %DIFF\")\n", + "plot_raster(nbr_perdiff, fig, ax[2,1], \"NBR %DIFF\")\n", + "plot_raster(nbr2_perdiff, fig, ax[3,0], \"NBR2 %DIFF\")\n", + "plot_raster(evi_perdiff, fig, ax[3,1], \"EVI %DIFF\")\n", + "plot_raster(msavi_perdiff, fig, ax[4,0], \"msavi %DIFF\")\n", + "plot_raster(tvi_perdiff, fig, ax[4,1], \"tvi %DIFF\")\n", + "plot_raster(savi_perdiff, fig, ax[5,0], \"SAVI %DIFF\")\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "f1176981", + "metadata": {}, + "source": [ + "## Check reading data with a few readers" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "21a69981", + "metadata": {}, + "outputs": [], + "source": [ + "ndvi_tif = f\"{sr_key_vi}.NDVI.tif\"\n", + "xidx = 3000\n", + "yidx = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "95349242", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2075\n" + ] + } + ], + "source": [ + "# using rasterio\n", + "data = rasterio.open(ndvi_tif)\n", + "print(data.read(1)[xidx, yidx])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ec4afd44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2075\n" + ] + } + ], + "source": [ + "# Using xarray\n", + "import xarray\n", + "data = xarray.open_dataset(ndvi_tif, mask_and_scale=False)\n", + "print(data.to_array().squeeze()[xidx, yidx].values)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e6bbb3b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2075\n" + ] + } + ], + "source": [ + "# Using rioxarray\n", + "import rioxarray\n", + "data = rioxarray.open_rasterio(ndvi_tif)\n", + "print(data.values[0][xidx, yidx])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dd52f54", + "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.10.15" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}