diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..67e36ae --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,50 @@ +name: CI + +on: + push: + branches: [master, library-overhaul] + pull_request: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + test: + name: test (py${{ matrix.python-version }}, ${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + python-version: ["3.10", "3.11", "3.12"] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: pip + - name: Install + run: | + python -m pip install --upgrade pip + python -m pip install -e ".[fit,test]" + - name: Lint + run: | + ruff check . + ruff format --check . + - name: Test + run: pytest -q --cov=phenosensing --cov-report=term-missing + + build: + name: build distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.11" + - name: Build & check + run: | + python -m pip install --upgrade pip build twine + python -m build + python -m twine check dist/* diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0e6b33b --- /dev/null +++ b/.gitignore @@ -0,0 +1,22 @@ +# Python +__pycache__/ +*.py[cod] +*.egg-info/ +.eggs/ +build/ +dist/ +site/ + +# Notebooks / tooling caches +.ipynb_checkpoints/ +.pytest_cache/ +.ruff_cache/ +.mypy_cache/ +.coverage +htmlcov/ + +# Locally cached Earth Engine downloads (see examples/earthengine_*.ipynb) +examples/data/ + +# OS +.DS_Store diff --git a/README.md b/README.md index 6d884dc..011bd46 100644 --- a/README.md +++ b/README.md @@ -1,39 +1,81 @@ -# PhenoPY

- + +PhenoSensing +

-

Python bindings for Phenological analysis of Remote Sensing data

+

Land surface phenology from satellite image time series, built on xarray and Dask

- - Gitter - - - - - + Python 3.10+ + MIT License

-### Library dependencies: -- Python < 3.6 -- rasterstats -- rasterio -- xarrar -- rioxarray -- shapely -- pandas -- numpy -- scipy -- matplotlib -- tqdm +PhenoSensing reconstructs a smoothed seasonal *phenological shape* for every pixel of +a vegetation-index (NDVI, EVI, kNDVI, SIF, …) time series and extracts **16 +land-surface-phenology (LSP) metrics** from it, with first-class support for +**interannual** analysis and the **Southern Hemisphere**. +## Highlights -### Documentation comming soon... +- A clean `xarray` accessor: `da.pheno.PhenoShape(...).pheno.PhenoLSP()`. +- **16 LSP metrics**: SOS, POS, EOS, vSOS/vPOS/vEOS, LOS, MSP, MAU, vMSP/vMAU, + amplitude, integral, rates of greening/senescence, and skewness. +- **Interannual time series** via a moving multi-year window + (`get_timeseries_metrics`). +- **Curvature** and **(segmented) RMSE** goodness-of-fit. +- **Southern-Hemisphere** day-of-year reordering. +- **Dask-aware** for larger-than-memory rasters. -### Example: +> [!NOTE] +> PhenoSensing is the modernized successor to **PhenoPY**, renamed because +> `phenopy` is taken on PyPI by an unrelated clinical-phenotyping tool. It +> installs and imports as **`phenosensing`** (the xarray accessor stays +> `da.pheno`). A PyPI/conda release is in preparation. -Monthly time series data of SIF (satellite-retrieved solar-induced chlorophyll fluorescence) depicted from Chen et al. (2022; https://www.nature.com/articles/s41597-022-01520-1). The area here is a small sample for Chile. +## Installation -See the Notebook at: https://github.com/JavierLopatin/PhenoPY/blob/master/phenopy/ExampleData.ipynb +From source for now (a PyPI/conda release is in progress): +```bash +git clone https://github.com/JavierLopatin/PhenoSensing.git +cd PhenoSensing + +# Recommended: conda dev environment (reliable geospatial stack) +conda env create -f environment-dev.yml +conda activate phenosensing +pip install -e ".[fit,plot,test]" +``` + +Optional extras: `plot` (matplotlib/folium/pyproj), `fit` +(whittaker-eilers/pymannkendall), `kde` (KDEpy), `fast` (numba), +`test`, `docs`. + +## Quickstart + +```python +import phenosensing +from phenosensing import load_sample + +# Bundled example: SIF time series over Chile (2001-2020) +da = load_sample("SIF") # (time, y, x) with doy/year coords + +# 1. Reconstruct a smoothed phenological shape per pixel +shape = da.pheno.PhenoShape(interpolType="linear", rollWindow=5, nGS=52) + +# 2. Extract the 16 land-surface-phenology metrics +lsp = shape.pheno.PhenoLSP() # xarray.Dataset: sos, pos, eos, ... + +# 3. Interannual time series via a moving multi-year window +ts = da.pheno.get_timeseries_metrics(window_length=3, metric=["sos", "pos", "eos"]) +``` + +A full walk-through is in the example notebook: +[`phenosensing/ExampleData.ipynb`](https://github.com/JavierLopatin/PhenoSensing/blob/master/phenosensing/ExampleData.ipynb), +and an **executed tutorial exercising every function** is in +[`examples/tutorial.ipynb`](examples/tutorial.ipynb). +The example SIF data is a small sample over Chile, derived from +[Chen et al. (2022)](https://www.nature.com/articles/s41597-022-01520-1). + +## License + +MIT — see [LICENSE.txt](LICENSE.txt). diff --git a/__init__.py b/__init__.py deleted file mode 100644 index 56644d4..0000000 --- a/__init__.py +++ /dev/null @@ -1 +0,0 @@ -name = 'phenopy' diff --git a/benchmarks/bench.py b/benchmarks/bench.py new file mode 100644 index 0000000..926c199 --- /dev/null +++ b/benchmarks/bench.py @@ -0,0 +1,96 @@ +"""Benchmarks for PhenoSensing's two scaling paths. + +Run from the repo root in the dev env:: + + python benchmarks/bench.py + +1. **Reconstruction** (``PhenoShape``, linear): the Numba ``[fast]`` kernel vs the + pure-Python path -- a single-core, in-memory acceleration of the hot loop. +2. **Extraction** (``PhenoLSP``): eager single-core vs chunked + the Dask + ``processes`` scheduler -- i.e. how the *single* NumPy/scipy implementation + scales across cores without a second code path (no Numba kernel needed). + +Both checks assert the parallel result is identical to the serial one. +""" + +import time + +import dask +import numpy as np +import xarray as xr + +import phenosensing # noqa: F401 (registers the `pheno` accessor) +from phenosensing import _numba +from phenosensing.io import load_sample + + +def tile(da, reps): + """Tile the sample spatially to build a larger synthetic raster.""" + big = xr.concat([da] * reps, dim="y") + big = xr.concat([big] * reps, dim="x") + return big.assign_coords(y=np.arange(big.sizes["y"]), x=np.arange(big.sizes["x"])) + + +def timed(fn): + t0 = time.perf_counter() + out = fn() + np.asarray(out.values) # realise the computation + return time.perf_counter() - t0, out + + +def bench_reconstruction(da): + """PhenoShape(linear): Numba fast path vs pure-Python (single core, in memory).""" + print("\n== Reconstruction: PhenoShape(linear) ==") + params = dict(interpolType="linear", rollWindow=5, nGS=52) + if _numba.NUMBA_AVAILABLE: + load_sample("SIF").pheno.PhenoShape(**params) # warm up the JIT (exclude compile time) + t_numba, out_numba = timed(lambda: da.pheno.PhenoShape(**params)) + print(f" numba [fast] : {t_numba:6.2f} s") + + orig = _numba.NUMBA_AVAILABLE + _numba.NUMBA_AVAILABLE = False + try: + t_py, out_py = timed(lambda: da.pheno.PhenoShape(**params)) + finally: + _numba.NUMBA_AVAILABLE = orig + print(f" pure-Python : {t_py:6.2f} s") + if t_numba > 0: + print(f" speedup : x{t_py / t_numba:.1f}") + np.testing.assert_allclose(out_numba.values, out_py.values, rtol=1e-5, equal_nan=True) + print(" identical : OK") + return out_numba # reuse as the PhenoLSP input + + +def bench_extraction(shape, n_tiles=4): + """PhenoLSP: eager (1 core) vs chunked + Dask 'processes' (multi-core).""" + print("\n== Extraction: PhenoLSP (eager vs Dask processes) ==") + t_eager, lsp_eager = timed(lambda: shape.pheno.PhenoLSP().compute()) + print(f" eager (1 core) : {t_eager:6.2f} s") + + cy = max(shape.sizes["y"] // n_tiles, 1) + cx = max(shape.sizes["x"] // n_tiles, 1) + shape_ch = shape.chunk({"y": cy, "x": cx}) + with dask.config.set(scheduler="processes"): + t_par, lsp_par = timed(lambda: shape_ch.pheno.PhenoLSP().compute()) + print(f" Dask processes : {t_par:6.2f} s ({n_tiles * n_tiles} tiles)") + if t_par > 0: + print(f" speedup : x{t_eager / t_par:.1f}") + for band in lsp_eager.data_vars: + np.testing.assert_allclose( + lsp_eager[band].values, lsp_par[band].values, rtol=1e-5, equal_nan=True + ) + print(" identical : OK") + + +def main(): + da = tile(load_sample("SIF"), reps=8) + npix = da.sizes["y"] * da.sizes["x"] + print(f"raster: {dict(da.sizes)} ({npix} pixels, {da.sizes['time']} time steps)") + print(f"numba available: {_numba.NUMBA_AVAILABLE}") + + shape = bench_reconstruction(da) + bench_extraction(shape) + + +if __name__ == "__main__": + main() diff --git a/docs/api.md b/docs/api.md new file mode 100644 index 0000000..e181956 --- /dev/null +++ b/docs/api.md @@ -0,0 +1,41 @@ +# API reference + +## The `pheno` accessor + +::: phenosensing.phenosensing.Pheno + options: + members: + - PhenoShape + - PhenoLSP + - RMSE + - get_timeseries_metrics + +## Analysis layers + +::: phenosensing.trends.trend + +::: phenosensing.anomaly.anomaly + +::: phenosensing.uncertainty.uncertainty + +## Method registries + +::: phenosensing.reconstruction.list_reconstructors + +::: phenosensing.extraction.list_extractors + +## Shape analysis + +::: phenosensing.curvature.get_curvature + +::: phenosensing.season.n_seasons + +## I/O + +::: phenosensing.io.load_sample + +::: phenosensing.io.list_samples + +## Utilities + +::: phenosensing.utils.reorder_southern_hemisphere diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..0f26e44 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,29 @@ +# PhenoSensing + +Land surface phenology metrics from satellite image time series, built on +[xarray](https://docs.xarray.dev) and Dask. + +PhenoSensing reconstructs a smoothed seasonal *phenological shape* for every pixel of +a vegetation-index time series and extracts 16 land-surface-phenology (LSP) +metrics from it — start/peak/end of season, rates, integrals, amplitude and +more — with first-class support for **interannual** analysis and the **Southern +Hemisphere**. + +## Highlights + +- A clean `xarray` accessor: `da.pheno.PhenoShape(...).pheno.PhenoLSP()`. +- 16 LSP metrics (SOS, POS, EOS, vSOS/vPOS/vEOS, LOS, MSP, MAU, amplitude, + integral, rates of greening/senescence, skewness). +- Interannual time series via a moving multi-year window + (`get_timeseries_metrics`). +- Curvature and (segmented) RMSE goodness-of-fit. +- Southern-Hemisphere day-of-year reordering. +- Dask-aware for larger-than-memory rasters. + +See **[Quickstart](quickstart.md)** to get going in a few lines, or the +**[API reference](api.md)** for the full surface. + +!!! note + PhenoSensing is being modernized toward a PyPI/conda release. The core accessor + API is stable, while new reconstruction and extraction methods are being + added. diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..28d42fe --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,33 @@ +# Installation + +PhenoSensing is being prepared for a PyPI/conda release. For now, install from source. + +## Conda development environment (recommended) + +The geospatial stack (GDAL / rasterio / rioxarray) resolves most reliably on +conda-forge: + +```bash +git clone https://github.com/JavierLopatin/PhenoSensing.git +cd PhenoSensing +conda env create -f environment-dev.yml +conda activate phenosensing +pip install -e ".[fit,plot,test]" +``` + +## Plain pip + +```bash +pip install -e ".[fit,plot]" +``` + +## Optional extras + +| Extra | Adds | +| ------ | --------------------------------------------------- | +| `plot` | matplotlib, folium, pyproj (plotting / maps) | +| `fit` | whittaker-eilers, pymannkendall (smoothing, trends) | +| `kde` | KDEpy (non-parametric reconstruction) | +| `fast` | numba (accelerated kernels) | +| `test` | pytest, pytest-cov, ruff | +| `docs` | mkdocs-material, mkdocstrings | diff --git a/docs/performance.md b/docs/performance.md new file mode 100644 index 0000000..746d37f --- /dev/null +++ b/docs/performance.md @@ -0,0 +1,101 @@ +# Performance & scaling + +PhenoSensing keeps **one readable reference implementation** per axis (NumPy/SciPy, +mapped per pixel with `xarray.apply_ufunc`) and scales it two ways — it never +ships a second copy of an algorithm. The two knobs: + +## TL;DR — which knob when + +| Situation | Use | +|---|---| +| In-memory raster, **linear** reconstruction | Nothing — the Numba `[fast]` kernel is used automatically (~12× over pure Python) | +| Raster **larger than RAM** | `chunks=` — process in spatial tiles, bounded memory | +| **Large** raster, want multi-core extraction / non-linear methods | Chunk + the Dask `processes` scheduler | +| Small / medium in-memory raster | Eager is usually fastest — skip the scheduler overhead | + +## Out-of-core / chunked processing + +Pass `chunks` to `PhenoShape` (or chunk the input yourself) to process a raster +in spatial tiles instead of loading it all into memory: + +```python +shape = da.pheno.PhenoShape(interpolType="linear", chunks={"x": 512, "y": 512}) +lsp = shape.pheno.PhenoLSP() # still lazy (Dask-backed) +lsp = lsp.compute() # realises the result, tile by tile +``` + +The time axis is always kept whole (each pixel needs its full series); only the +spatial dims are tiled. This keeps peak memory bounded and lets you process +rasters larger than RAM. + +## Numba fast path (linear reconstruction) + +With the `[fast]` extra (numba) installed, **linear** `PhenoShape` on an +in-memory raster automatically uses a GIL-releasing, Numba-parallel kernel — +about **12× faster** than the pure-Python path on a multi-core machine, with +identical results. No code change is needed; it is used whenever the inputs are +eligible (linear method, in memory, no NaNs, no custom params) and falls back to +the pure-Python path otherwise. + +```python +shape = da.pheno.PhenoShape(interpolType="linear") # Numba kernel if available +``` + +## Scaling extraction and the other methods (Dask) + +Metric extraction (`PhenoLSP`) and the non-linear reconstruction methods run the +single NumPy/SciPy implementation via `numpy.vectorize`. Because that path holds +the GIL, the default *threaded* Dask scheduler helps **memory** (out-of-core) but +not wall-clock; for CPU parallelism use the *process* scheduler on a chunked +input: + +```python +import dask + +shape = da.pheno.PhenoShape(chunks={"x": 256, "y": 256}) +with dask.config.set(scheduler="processes"): + lsp = shape.pheno.PhenoLSP().compute() +``` + +**Honest expectation:** the `processes` scheduler pays a per-worker start-up cost +(each process re-imports the scientific stack and tiles are pickled to it), so on +*small / medium in-memory* rasters the speed-up is modest and eager may even win. +The benefit grows with raster size — where per-tile compute dwarfs the start-up +cost — and the primary reason to chunk at all is **bounded memory** (processing +larger-than-RAM data), not raw speed. Benchmark on *your* data and hardware. + +## Why there is no Numba kernel for extraction + +A deliberate design choice for robustness. Extraction calls SciPy +(`scipy.stats.skew`, `scipy.integrate.trapezoid`) and dispatches through the +Python extractor registry (axis 3) — neither of which Numba's `@njit` can +compile. A Numba kernel would therefore be a **second implementation** of the +18-metric logic that must stay byte-for-byte identical to the reference one +forever: a maintenance and drift hazard for a marginal, default-path-only gain. + +So PhenoSensing keeps **one** implementation and scales it with Dask, and reserves +Numba for the place it is a clean win: the hot, simple, SciPy-free linear +reconstruction loop. (A pure-NumPy micro-optimisation of `_getLSPmetrics2` — one +implementation, faster for every backend — is the preferred next step if +extraction proves to be a bottleneck.) + +## Choosing chunk sizes + +`phenosensing.utils.computeChunkSize` suggests a chunking that targets ~100 MB tiles +while keeping the time axis whole: + +```python +from phenosensing.utils import computeChunkSize + +chunks = computeChunkSize(da, sizeMB=100) +shape = da.pheno.PhenoShape(chunks=chunks) +``` + +## Benchmarks + +`benchmarks/bench.py` (run from the repo root in the dev env) times both paths on +a tiled copy of the bundled SIF sample and **asserts the parallel result equals +the serial one**: + +1. `PhenoShape(linear)` — Numba `[fast]` vs pure-Python. +2. `PhenoLSP` — eager (1 core) vs chunked + Dask `processes`. diff --git a/docs/quickstart.md b/docs/quickstart.md new file mode 100644 index 0000000..bd8a549 --- /dev/null +++ b/docs/quickstart.md @@ -0,0 +1,64 @@ +# Quickstart + +```python +import phenosensing +from phenosensing import load_sample + +# Bundled example: SIF time series over Chile (2001-2020) +da = load_sample("SIF") # (time, y, x) with doy/year coords + +# 1. Reconstruct a smoothed phenological shape per pixel +shape = da.pheno.PhenoShape(interpolType="linear", rollWindow=5, nGS=52) + +# 2. Extract the 16 land-surface-phenology metrics +lsp = shape.pheno.PhenoLSP() # xarray.Dataset: sos, pos, eos, ... + +# 3. Goodness-of-fit (optionally segmented by SOS / POS / EOS) +rmse = shape.pheno.RMSE(da, LSP_stack=lsp, normalized=True, segment=True) + +# 4. Interannual time series via a moving multi-year window +ts = da.pheno.get_timeseries_metrics(window_length=3, metric=["sos", "pos", "eos"]) +``` + +## The metrics + +`PhenoLSP` returns an `xarray.Dataset` with 16 variables: + +| Group | Variables | +| ----------- | ---------------------------------- | +| Timing | `sos`, `pos`, `eos` | +| Values | `vsos`, `vpos`, `veos` | +| Season | `los`, `ampl`, `ios` | +| Spring/Aut. | `msp`, `mau`, `vmsp`, `vmau` | +| Rates/shape | `rog`, `ros`, `sw` | + +## Trends and anomalies + +```python +from phenosensing import anomaly, n_seasons, trend, uncertainty + +# Interannual trend of start-of-season: Theil-Sen slope + Mann-Kendall p-value +ts = da.pheno.get_timeseries_metrics(window_length=3, metric=["sos"]) +sos_trend = trend(ts["sos"]) + +# Per-observation phenological anomalies + RFD percentile (npphen-style) +an = anomaly(da) # -> Dataset with `anomaly`, `z`, `rfd` + +# Number of growing seasons per pixel (multi-cropping / bimodal vegetation) +nos = n_seasons(da.pheno.PhenoShape()) + +# Bootstrap uncertainty (std) of each of the 16 metrics, per pixel +unc = uncertainty(da, n_boot=50) +``` + +## Southern Hemisphere + +For Southern-Hemisphere sites, reorder the day-of-year so the growing season is +contiguous before computing the shape: + +```python +from phenosensing import reorder_southern_hemisphere + +positions, da_sh = reorder_southern_hemisphere(da) +shape = da_sh.pheno.PhenoShape() +``` diff --git a/environment-dev.yml b/environment-dev.yml new file mode 100644 index 0000000..5eb58c0 --- /dev/null +++ b/environment-dev.yml @@ -0,0 +1,45 @@ +# Development environment for PhenoSensing. +# Create with: conda env create -f environment-dev.yml (or use mamba) +# Then install the package in editable mode: pip install -e ".[fit,plot,dask,test,docs]" +# +# The geospatial stack (GDAL/rasterio/rioxarray) is pinned to conda-forge, +# where it resolves far more reliably than via pip wheels. +name: phenosensing +channels: + - conda-forge +dependencies: + - python=3.11 + # core scientific stack + - numpy + - scipy + - pandas + # geospatial / array + - xarray + - rioxarray + - rasterio + - rasterstats + - shapely + - dask + # performance + - numba + # plotting (optional extra) + - matplotlib + - folium + - pyproj + - tqdm + # dev / test / docs tooling + - pytest + - pytest-cov + - ruff + - python-build + - twine + - mkdocs-material + - ipykernel + - nbconvert + - pip + # pip-only packages (not reliably on conda-forge) + - pip: + - whittaker-eilers # Whittaker smoother (Wave 1) + - pymannkendall # trend tests (Wave 1) + - KDEpy # non-parametric KDE reconstruction (optional) + - mkdocstrings[python] diff --git a/examples/earthengine_torres_del_paine.ipynb b/examples/earthengine_torres_del_paine.ipynb new file mode 100644 index 0000000..c1aeb89 --- /dev/null +++ b/examples/earthengine_torres_del_paine.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ae2ad35e", + "metadata": {}, + "source": [ + "# PhenoSensing × Google Earth Engine — Torres del Paine (Patagonia)\n", + "\n", + "This notebook pulls **real, cloud-contaminated** optical NDVI **with a\n", + "per-observation quality band** from three sensors over Torres del Paine\n", + "(~51° S, Chilean Patagonia — one of the cloudiest places on Earth, so the\n", + "growing season is hard to see without quality weighting).\n", + "\n", + "**Design (important).** Earth Engine is used here only as an **example data\n", + "source — it is *not* a dependency of PhenoSensing.** The split is deliberate:\n", + "\n", + "- **Getting data into xarray** (the `gee_to_xarray` helper below) is example\n", + " code; swap it for local rasters / NetCDF and everything downstream is identical.\n", + "- **Decoding QA into weights** is done by the library, `phenosensing.qa.qa_to_weight`,\n", + " which is **source- and sensor-agnostic** (works on any xarray QA band).\n", + "- **The phenology algorithms** only ever see a generic `weight` array in [0, 1];\n", + " they never know which sensor it came from.\n", + "\n", + "> ⚠️ **You must run this yourself.** Earth Engine auth is an interactive Google\n", + "> login and needs a **Google Cloud project**; it cannot run in CI. The cells are\n", + "> saved *unexecuted*. Requires the `[gee]` extra (`earthengine-api`, `xee`)." + ] + }, + { + "cell_type": "markdown", + "id": "2696eb9b", + "metadata": {}, + "source": [ + "## 1. One-time setup: Earth Engine account + Google Cloud project\n", + "\n", + "1. **Register** your Google account at and\n", + " accept the terms (once).\n", + "2. **Create a Cloud project**: the Code Editor prompts you to, or go to\n", + " → *New Project* and note its **project ID**\n", + " (e.g. `ee-yourname`).\n", + "3. **Authenticate** once per machine: easiest is `earthengine authenticate` in a\n", + " terminal (it captures the token automatically — nothing to paste). Or run\n", + " `ee.Authenticate()` below.\n", + "4. Put your **project ID** in `PROJECT` and run `ee.Initialize(...)`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d02b307c", + "metadata": {}, + "outputs": [], + "source": [ + "import ee\n", + "\n", + "PROJECT = \"ee-your-project-id\" # <-- EDIT: your Google Cloud project ID\n", + "\n", + "# Run once per machine; comment out after the token is saved.\n", + "ee.Authenticate()\n", + "\n", + "# xee works best against the high-volume endpoint.\n", + "ee.Initialize(project=PROJECT, opt_url=\"https://earthengine-highvolume.googleapis.com\")\n", + "print(\"Earth Engine initialised for project:\", PROJECT)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98c0a8ca", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import phenosensing\n", + "import phenosensing.qa as pqa # <-- the source-agnostic QA decoder\n", + "from phenosensing.plotting import PhenoPlot, display_map\n", + "print(\"phenosensing\", phenosensing.__version__, \"| xarray\", xr.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "c83d494c", + "metadata": {}, + "source": [ + "## 2. Area of interest, period & common grid\n", + "\n", + "A small box over the eastern Patagonian steppe of Torres del Paine (vegetated;\n", + "avoids the rock/ice/lakes of the massif). `xee 0.1.1` samples onto an explicit\n", + "grid (CRS + affine transform + width/height); using **one common grid for all\n", + "three sensors** makes them directly comparable, pixel for pixel.\n", + "\n", + "Southern Hemisphere: the season peaks around the New Year (Dec–Feb), so it is\n", + "split on a calendar-DOY axis — a natural fit for PhenoSensing's `southern=True`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73ac463c", + "metadata": {}, + "outputs": [], + "source": [ + "# [west, south, east, north] around the Laguna Amarga / Sarmiento steppe\n", + "WEST, SOUTH, EAST, NORTH = -72.95, -51.01, -72.89, -50.97\n", + "geom = ee.Geometry.Rectangle([WEST, SOUTH, EAST, NORTH])\n", + "\n", + "START, END = \"2019-01-01\", \"2024-01-01\" # 5 austral seasons\n", + "\n", + "CRS = \"EPSG:4326\"\n", + "PIXEL = 0.0025 # ~250 m in latitude degrees\n", + "WIDTH, HEIGHT = round((EAST - WEST) / PIXEL), round((NORTH - SOUTH) / PIXEL)\n", + "CRS_TRANSFORM = (PIXEL, 0.0, WEST, 0.0, -PIXEL, NORTH) # affine: (sx, 0, x0, 0, -sy, y0)\n", + "SHAPE_2D = (WIDTH, HEIGHT)\n", + "print(f\"common grid: {WIDTH} x {HEIGHT} px\")\n", + "\n", + "# quick interactive check of the box (folium; needs the [plot] extra)\n", + "display_map((WEST, EAST), (SOUTH, NORTH))" + ] + }, + { + "cell_type": "markdown", + "id": "67b70def", + "metadata": {}, + "source": [ + "## 3. Per-sensor collections: NDVI + the *raw* QA band\n", + "\n", + "Each helper returns an `ee.ImageCollection` with `ndvi` plus that sensor's **raw\n", + "quality band** — note we do **not** decode QA here; that is the library's job\n", + "(§4). Computing NDVI from surface-reflectance bands and the GEE specifics all\n", + "live in this example layer, not in PhenoSensing.\n", + "\n", + "- **MODIS MOD13Q1** — precomputed NDVI + `SummaryQA` (ordinal 0–3).\n", + "- **Landsat 8/9 C2 L2** — NDVI from scaled SR bands + `QA_PIXEL` (bitmask).\n", + "- **Sentinel-2 SR Harmonized** — NDVI from B8/B4 + `SCL` (scene classes)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff2b13e6", + "metadata": {}, + "outputs": [], + "source": [ + "def modis(geom, start, end):\n", + " ic = ee.ImageCollection(\"MODIS/061/MOD13Q1\").filterBounds(geom).filterDate(start, end)\n", + " def prep(img):\n", + " ndvi = img.select(\"NDVI\").multiply(0.0001).rename(\"ndvi\")\n", + " return ndvi.addBands(img.select(\"SummaryQA\")).set(\n", + " \"system:time_start\", img.get(\"system:time_start\"))\n", + " return ic.map(prep).select([\"ndvi\", \"SummaryQA\"])\n", + "\n", + "\n", + "def landsat(geom, start, end):\n", + " def prep(img):\n", + " sr = img.select([\"SR_B4\", \"SR_B5\"]).multiply(0.0000275).add(-0.2) # C2 SR scaling\n", + " ndvi = sr.normalizedDifference([\"SR_B5\", \"SR_B4\"]).rename(\"ndvi\") # (NIR-Red)/(NIR+Red)\n", + " return ndvi.addBands(img.select(\"QA_PIXEL\")).set(\n", + " \"system:time_start\", img.get(\"system:time_start\"))\n", + " l8 = ee.ImageCollection(\"LANDSAT/LC08/C02/T1_L2\").filterBounds(geom).filterDate(start, end)\n", + " l9 = ee.ImageCollection(\"LANDSAT/LC09/C02/T1_L2\").filterBounds(geom).filterDate(start, end)\n", + " return l8.merge(l9).map(prep).select([\"ndvi\", \"QA_PIXEL\"])\n", + "\n", + "\n", + "def s2(geom, start, end):\n", + " ic = ee.ImageCollection(\"COPERNICUS/S2_SR_HARMONIZED\").filterBounds(geom).filterDate(start, end)\n", + " def prep(img):\n", + " ndvi = img.normalizedDifference([\"B8\", \"B4\"]).rename(\"ndvi\")\n", + " return ndvi.addBands(img.select(\"SCL\")).set(\n", + " \"system:time_start\", img.get(\"system:time_start\"))\n", + " return ic.map(prep).select([\"ndvi\", \"SCL\"])\n", + "\n", + "\n", + "# sensor -> (collection builder, phenosensing.qa registry key)\n", + "SENSORS = {\"MODIS\": (modis, \"MOD13Q1\"), \"Landsat\": (landsat, \"LANDSAT_C2\"), \"S2\": (s2, \"S2_SCL\")}" + ] + }, + { + "cell_type": "markdown", + "id": "775e975d", + "metadata": {}, + "source": [ + "### The library decoder — `phenosensing.qa`\n", + "\n", + "`phenosensing.qa.qa_to_weight(qa, spec)` turns any xarray QA band into weights in\n", + "[0, 1]. `spec` can be a **built-in key**, a **declarative dict**, or a **callable**\n", + "for anything exotic — so a new sensor is one line, not a new code path. The four\n", + "patterns it covers: `remap` (ordinal), `good_classes` (labels), `bad_bits`\n", + "(bitmask), `max_value`/`min_value` (threshold)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ee04a46", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"built-in specs:\", pqa.list_qa_specs())\n", + "print(\"S2_SCL rule :\", pqa.get_qa_spec(\"S2_SCL\"))\n", + "\n", + "# A less-typical sensor needs no library change — just pass a dict ...\n", + "cloudprob_spec = {\"max_value\": 30} # keep cloud-probability <= 30 %\n", + "# ... or a callable for anything that fits no pattern:\n", + "custom = lambda qa: (qa < 2).astype(float) # noqa: E731 (illustrative)\n", + "print(\"ad-hoc dict / callable are accepted directly by qa_to_weight()\")" + ] + }, + { + "cell_type": "markdown", + "id": "f28c6e2f", + "metadata": {}, + "source": [ + "## 4. Pull each cube (`gee_to_xarray`) and decode QA with `phenosensing.qa`\n", + "\n", + "`gee_to_xarray` is the **example** GEE → xarray bridge (swap it for any loader).\n", + "For each sensor we then call the **library** `qa_to_weight` on the downloaded raw\n", + "QA band. (S2 is the densest collection, but on this tiny grid all three take only\n", + "seconds.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "068efcfa", + "metadata": {}, + "outputs": [], + "source": [ + "def gee_to_xarray(collection, crs, crs_transform, shape_2d):\n", + " \"\"\"Example GEE -> xarray bridge. Earth Engine is NOT a PhenoSensing dependency;\n", + " this helper lives in the example, not the library. Swap it for rioxarray /\n", + " open_dataset on local files and everything below is unchanged.\"\"\"\n", + " ds = xr.open_dataset(\n", + " collection, engine=\"ee\", crs=crs, crs_transform=crs_transform, shape_2d=shape_2d\n", + " ).load()\n", + " ds = ds.sortby(\"time\")\n", + " return ds.assign_coords(\n", + " doy=(\"time\", ds[\"time\"].dt.dayofyear.data),\n", + " year=(\"time\", ds[\"time\"].dt.year.data),\n", + " )\n", + "\n", + "\n", + "cubes = {}\n", + "for name, (build, qa_key) in SENSORS.items():\n", + " ds = gee_to_xarray(build(geom, START, END), CRS, CRS_TRANSFORM, SHAPE_2D)\n", + " qa_band = pqa.get_qa_spec(qa_key)[\"band\"] # which band holds the QA\n", + " weight = pqa.qa_to_weight(ds[qa_band], qa_key) # <-- library, sensor-agnostic\n", + " cubes[name] = (ds[\"ndvi\"], weight)\n", + " print(f\"{name:8s} -> {dict(ds['ndvi'].sizes)} \"\n", + " f\"({int(np.isfinite(ds['ndvi']).sum())} finite NDVI, mean QA weight {float(weight.mean()):.2f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "ce68d566", + "metadata": {}, + "source": [ + "## 5. The problem QA weighting solves\n", + "\n", + "Colour each observation of one pixel by its decoded QA weight: in cloudy Patagonia\n", + "the **low-weight (red) points sit well below** the clean (green) ones — the\n", + "asymmetric, downward contamination that drags an unweighted smoother down." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acb29c48", + "metadata": {}, + "outputs": [], + "source": [ + "name = \"S2\" # the densest / cloudiest series shows it best\n", + "ndvi, weight = cubes[name]\n", + "yc, xc = ndvi.sizes[\"y\"] // 2, ndvi.sizes[\"x\"] // 2\n", + "ts, wt = ndvi.isel(y=yc, x=xc), weight.isel(y=yc, x=xc)\n", + "\n", + "plt.figure(figsize=(9, 4))\n", + "sc = plt.scatter(ts[\"doy\"], ts, c=wt, cmap=\"RdYlGn\", vmin=0, vmax=1, s=14)\n", + "plt.colorbar(sc, label=\"QA weight\")\n", + "plt.xlabel(\"Day of year\"); plt.ylabel(\"NDVI\")\n", + "plt.title(f\"{name}: observations coloured by phenosensing.qa weight (low = cloud/shadow/snow)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c347ac9f", + "metadata": {}, + "source": [ + "## 6. Weighted vs unweighted reconstruction\n", + "\n", + "Three reconstructions of the same cloudy pixel:\n", + "- **unweighted** Whittaker — dragged down by the cloud-contaminated lows;\n", + "- **QA-weighted** Whittaker — `weights` from `phenosensing.qa` down-weight bad\n", + " observations (`PhenoShape(weights=...)`);\n", + "- **upper-envelope** (Chen / TIMESAT wTSM) — tracks the noise-free upper envelope,\n", + " no QA band needed.\n", + "\n", + "In cloudy Patagonia the unweighted curve sits far too low; both weighted methods\n", + "recover the real vegetation signal (most dramatic for Sentinel-2 / Landsat, whose\n", + "raw per-scene data is heavily cloud-contaminated)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04080472", + "metadata": {}, + "outputs": [], + "source": [ + "name = \"S2\" # the cloudiest series -> clearest contrast\n", + "ndvi, weight = cubes[name]\n", + "yc, xc = ndvi.sizes[\"y\"] // 2, ndvi.sizes[\"x\"] // 2\n", + "rp = {\"lmbd\": 50}\n", + "\n", + "unweighted = ndvi.pheno.PhenoShape(interpolType=\"whittaker\", recon_params=rp, rollWindow=None)\n", + "qa_weighted = ndvi.pheno.PhenoShape(\n", + " interpolType=\"whittaker\", recon_params=rp, rollWindow=None, weights=weight\n", + ")\n", + "envelope = ndvi.pheno.PhenoShape(\n", + " interpolType=\"upper_envelope\",\n", + " recon_params={\"base\": \"whittaker\", \"n_iter\": 5, \"base_params\": rp},\n", + " rollWindow=None,\n", + ")\n", + "\n", + "plt.figure(figsize=(9, 5))\n", + "ts, wt = ndvi.isel(y=yc, x=xc), weight.isel(y=yc, x=xc)\n", + "sc = plt.scatter(ts[\"doy\"], ts, c=wt, cmap=\"RdYlGn\", vmin=0, vmax=1, s=12)\n", + "plt.colorbar(sc, label=\"QA weight\")\n", + "plt.plot(unweighted[\"doy\"], unweighted.isel(y=yc, x=xc), color=\"0.4\", ls=\"--\", lw=2, label=\"unweighted\")\n", + "plt.plot(qa_weighted[\"doy\"], qa_weighted.isel(y=yc, x=xc), color=\"C0\", lw=2.5, label=\"QA-weighted Whittaker\")\n", + "plt.plot(envelope[\"doy\"], envelope.isel(y=yc, x=xc), color=\"C3\", lw=2, label=\"upper-envelope (wTSM/Chen)\")\n", + "plt.xlabel(\"Day of year\"); plt.ylabel(\"NDVI\"); plt.legend(loc=\"upper left\")\n", + "plt.title(f\"{name}: weighting / upper-envelope recover the cloud-suppressed signal\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e222695c", + "metadata": {}, + "source": [ + "## 7. Cache locally — the real-data fixture\n", + "\n", + "Save each `(ndvi, weight)` cube under `examples/data/` so the regression tests and\n", + "further analysis don't hit Earth Engine again. (`examples/data/` is git-ignored;\n", + "downsample to a tiny committable fixture later if useful.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7549462f", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "# robust whether the notebook's CWD is the repo root or the examples/ folder\n", + "here = Path.cwd()\n", + "outdir = here / \"examples\" / \"data\" if (here / \"examples\").is_dir() else here / \"data\"\n", + "outdir.mkdir(parents=True, exist_ok=True)\n", + "for name, (ndvi, weight) in cubes.items():\n", + " out = outdir / f\"torres_del_paine_{name}.nc\"\n", + " xr.Dataset({\"ndvi\": ndvi, \"weight\": weight}).to_netcdf(out)\n", + " print(\"wrote\", out)" + ] + }, + { + "cell_type": "markdown", + "id": "570222e9", + "metadata": {}, + "source": [ + "## 8. Recap\n", + "\n", + "The weights from `phenosensing.qa` feed the library's **weighted reconstruction**\n", + "(now implemented):\n", + "\n", + "- `PhenoShape(weights=...)` — weighted Whittaker driven by the QA weights;\n", + "- `interpolType=\"upper_envelope\"` — Chen / TIMESAT wTSM upper-envelope iteration,\n", + " no QA band needed;\n", + "- the default unweighted path is unchanged (byte-identical, golden tests green).\n", + "\n", + "From here the cached `examples/data/` cubes are a real-data fixture for regression\n", + "tests and for comparing the LSP metrics (SOS/POS/EOS …) extracted from weighted\n", + "vs unweighted curves." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/tutorial.ipynb b/examples/tutorial.ipynb new file mode 100644 index 0000000..5de53f6 --- /dev/null +++ b/examples/tutorial.ipynb @@ -0,0 +1,1748 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e6314e56", + "metadata": {}, + "source": [ + "# PhenoSensing — full API tutorial\n", + "\n", + "This notebook exercises **every public function** of PhenoSensing on the bundled\n", + "example datasets, as an end-to-end tutorial. The final section lists what the\n", + "bundled data *cannot* cover and the data that would be needed.\n", + "\n", + "**Bundled datasets**\n", + "- **SIF** — solar-induced fluorescence over Chile (Southern Hemisphere),\n", + " EPSG:4326, ~weekly, 2001–2020 (20 years).\n", + "- **ndvi** — NDVI, UTM 19S, 2018–2019.\n", + "\n", + "**The mental model.** PhenoSensing is organised around three orthogonal, *composable*\n", + "axes — any combination is valid:\n", + "\n", + "1. **Reconstruction** (§2) — *how* the noisy series is smoothed into one seasonal\n", + " curve (`interpolType`: linear, Savitzky–Golay, Whittaker, double-logistic, …).\n", + "2. **Extraction** (§3) — *how* start/peak/end of season are located on that curve\n", + " (`extraction`: seasonal_median, threshold, derivative, curvature).\n", + "3. **Temporal mode** — *which* years are pooled: one climatology (`PhenoShape`),\n", + " or a moving multi-year window (`get_timeseries_metrics`, §8).\n", + "\n", + "Trends (§9), anomalies (§10) and uncertainty (§11) are a **layer on top** of the\n", + "metrics these produce." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed7c0892", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:14.436924Z", + "iopub.status.busy": "2026-05-26T22:13:14.436822Z", + "iopub.status.idle": "2026-05-26T22:13:15.874060Z", + "shell.execute_reply": "2026-05-26T22:13:15.873536Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "phenosensing version : 0.1.0\n", + "samples : ['SIF', 'ndvi']\n", + "reconstructors : ['KDE', 'RBF', 'agauss', 'dlog_beck', 'dlog_elmore', 'linear', 'savgol', 'upper_envelope', 'whittaker']\n", + "extractors : ['curvature', 'der', 'seasonal_median', 'trs']\n", + "numba fast path : True\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import dask\n", + "\n", + "import phenosensing\n", + "from phenosensing import _numba\n", + "from phenosensing import (\n", + " load_sample, list_samples, list_reconstructors, list_extractors,\n", + " get_curvature, classify_vector_numeric, reorder_southern_hemisphere,\n", + " trend, anomaly, n_seasons, uncertainty,\n", + ")\n", + "\n", + "print(\"phenosensing version :\", phenosensing.__version__)\n", + "print(\"samples :\", list_samples())\n", + "print(\"reconstructors :\", list_reconstructors())\n", + "print(\"extractors :\", list_extractors())\n", + "print(\"numba fast path :\", _numba.NUMBA_AVAILABLE)" + ] + }, + { + "cell_type": "markdown", + "id": "325cd1e0", + "metadata": {}, + "source": [ + "## 1. Load the example data\n", + "\n", + "`load_sample(name)` returns a ready-to-use `(time, y, x)` `DataArray` with `doy`\n", + "(day-of-year) and `year` coordinates already derived from the acquisition dates —\n", + "the exact layout the `.pheno` accessor expects. The registry helpers list what is\n", + "available *without* loading anything:\n", + "\n", + "- `list_samples()` → bundled datasets (`\"SIF\"`, `\"ndvi\"`).\n", + "- `list_reconstructors()` → reconstruction methods (axis 1, §2).\n", + "- `list_extractors()` → SOS/EOS methods (axis 3, §3).\n", + "\n", + "A central pixel (`ys`, `xs`) is picked here for the 1-D plots that follow." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9b542094", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:15.875548Z", + "iopub.status.busy": "2026-05-26T22:13:15.875302Z", + "iopub.status.idle": "2026-05-26T22:13:15.921678Z", + "shell.execute_reply": "2026-05-26T22:13:15.921199Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 920, y: 17, x: 20)> Size: 1MB\n",
+       "[312800 values with dtype=float32]\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[us] 7kB 2001-01-01 2001-01-09 ... 2020-12-26\n",
+       "    doy          (time) int64 7kB 1 9 17 25 33 41 49 ... 321 329 337 345 353 361\n",
+       "    year         (time) int64 7kB 2001 2001 2001 2001 ... 2020 2020 2020 2020\n",
+       "  * y            (y) float64 136B -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n",
+       "  * x            (x) float64 160B -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n",
+       "    spatial_ref  int64 8B 0\n",
+       "Attributes:\n",
+       "    AREA_OR_POINT:  Area\n",
+       "    _FillValue:     -3.4e+38\n",
+       "    scale_factor:   1.0\n",
+       "    add_offset:     0.0
" + ], + "text/plain": [ + " Size: 1MB\n", + "[312800 values with dtype=float32]\n", + "Coordinates:\n", + " * time (time) datetime64[us] 7kB 2001-01-01 2001-01-09 ... 2020-12-26\n", + " doy (time) int64 7kB 1 9 17 25 33 41 49 ... 321 329 337 345 353 361\n", + " year (time) int64 7kB 2001 2001 2001 2001 ... 2020 2020 2020 2020\n", + " * y (y) float64 136B -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n", + " * x (x) float64 160B -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n", + " spatial_ref int64 8B 0\n", + "Attributes:\n", + " AREA_OR_POINT: Area\n", + " _FillValue: -3.4e+38\n", + " scale_factor: 1.0\n", + " add_offset: 0.0" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sif = load_sample(\"SIF\") # Chile, Southern Hemisphere, 2001-2020\n", + "ndvi = load_sample(\"ndvi\") # UTM 19S, 2018-2019\n", + "ys, xs = sif.sizes[\"y\"] // 2, sif.sizes[\"x\"] // 2 # a central pixel for 1-D plots\n", + "sif" + ] + }, + { + "cell_type": "markdown", + "id": "ff733bd6", + "metadata": {}, + "source": [ + "## 2. Reconstruction — `PhenoShape`\n", + "\n", + "`PhenoShape` is **axis 1**: it turns the raw, irregularly-sampled per-pixel series\n", + "into one smoothed **phenological curve** on a regular `doy` grid of length `nGS`,\n", + "pooling all years into a single climatological season. Main arguments:\n", + "\n", + "- **`interpolType`** — the reconstruction method (compared below):\n", + " - `linear` / `RBF` — interpolation of the raw points (fast; `linear` is the\n", + " default and has a Numba fast path).\n", + " - `savgol`, `whittaker` — robust *smoothers*, good for noisy optical data.\n", + " - `dlog_beck`, `dlog_elmore`, `agauss` — *model fits* (double-logistic /\n", + " asymmetric Gaussian) that impose a smooth single-season shape.\n", + " - `KDE` — kernel-density seasonal climatology (needs the `[kde]` extra).\n", + "- **`rollWindow`** — moving-average pre-smoothing of the raw series, in samples.\n", + "- **`nGS`** — number of points in the output curve (default 52 ≈ weekly).\n", + "- **`nan_replace`** — value treated as missing before fitting.\n", + "\n", + "The output keeps dims `(doy, y, x)`; that `doy` grid is what the LSP metrics are\n", + "read from. Methods trade fidelity against smoothness — pick one suited to the\n", + "sensor's noise level." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56d96035", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:15.922925Z", + "iopub.status.busy": "2026-05-26T22:13:15.922814Z", + "iopub.status.idle": "2026-05-26T22:13:16.153672Z", + "shell.execute_reply": "2026-05-26T22:13:16.153205Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PhenoShape -> {'doy': 52, 'y': 17, 'x': 20}\n" + ] + } + ], + "source": [ + "shape = sif.pheno.PhenoShape() # default: linear\n", + "print(\"PhenoShape ->\", dict(shape.sizes))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ab8150e3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:16.155376Z", + "iopub.status.busy": "2026-05-26T22:13:16.155255Z", + "iopub.status.idle": "2026-05-26T22:13:16.474147Z", + "shell.execute_reply": "2026-05-26T22:13:16.473678Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "An error occurred: A singular matrix detected: slice(s) [0] are singular.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pixel = sif.isel(y=ys, x=xs)\n", + "one = sif.isel(y=slice(ys, ys + 1), x=slice(xs, xs + 1))\n", + "plt.figure(figsize=(9, 5))\n", + "plt.plot(pixel.doy.values, pixel.values, \".\", ms=3, color=\"0.7\", label=\"observations\")\n", + "for method in [\"linear\", \"savgol\", \"whittaker\", \"dlog_beck\", \"dlog_elmore\", \"agauss\", \"RBF\", \"KDE\"]:\n", + " try:\n", + " s = one.pheno.PhenoShape(interpolType=method)\n", + " plt.plot(s.doy.values, s.isel(y=0, x=0).values, label=method)\n", + " except Exception as e:\n", + " print(f\"{method}: {type(e).__name__}: {e}\")\n", + "plt.legend(ncol=2); plt.xlabel(\"DOY\"); plt.ylabel(\"SIF\")\n", + "plt.title(\"Reconstruction methods (one pixel)\"); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cd499966", + "metadata": {}, + "source": [ + "Per-method parameters are passed through **`recon_params`** (a dict), so the\n", + "single `PhenoShape(interpolType=..., recon_params={...})` signature covers every\n", + "method. E.g. `savgol` takes `window_length` / `polyorder`, and `whittaker` takes\n", + "the smoothing strength `lmbd` (larger ⇒ smoother):" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a2e002b0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:16.475478Z", + "iopub.status.busy": "2026-05-26T22:13:16.475225Z", + "iopub.status.idle": "2026-05-26T22:13:16.481616Z", + "shell.execute_reply": "2026-05-26T22:13:16.481195Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "recon_params OK: {'doy': 52, 'y': 1, 'x': 1} {'doy': 52, 'y': 1, 'x': 1}\n" + ] + } + ], + "source": [ + "s_sg = one.pheno.PhenoShape(interpolType=\"savgol\", recon_params={\"window_length\": 11, \"polyorder\": 3})\n", + "s_wh = one.pheno.PhenoShape(interpolType=\"whittaker\", recon_params={\"lmbd\": 50.0})\n", + "print(\"recon_params OK:\", dict(s_sg.sizes), dict(s_wh.sizes))" + ] + }, + { + "cell_type": "markdown", + "id": "0ca4394b", + "metadata": {}, + "source": [ + "## 3. Land-surface phenology metrics — `PhenoLSP`\n", + "\n", + "`PhenoLSP` reads a `PhenoShape` curve and returns the **18 LSP metrics** per pixel\n", + "as a `Dataset`. Timing metrics are in DOY; value metrics are in the index's units\n", + "(here SIF). The peak (POS) is the curve maximum; SOS/EOS come from **axis 3**, the\n", + "`extraction` method.\n", + "\n", + "| metric | meaning |\n", + "|---|---|\n", + "| `sos`, `pos`, `eos` | DOY of start / peak / end of season |\n", + "| `vsos`, `vpos`, `veos` | curve value at SOS / POS / EOS (`vpos` = seasonal max) |\n", + "| `los` | length of season = `eos − sos` (days) |\n", + "| `msp`, `mau` | DOY midway through green-up (spring) and senescence (autumn) |\n", + "| `vmsp`, `vmau` | curve value at `msp` / `mau` |\n", + "| `ampl` | amplitude = `vpos − trough` |\n", + "| `ios` | integral of the season (area under the curve, SOS→EOS) |\n", + "| `rog`, `ros` | rate of greening (SOS→POS) and senescence (POS→EOS) — slopes |\n", + "| `sw` | skewness of the growing-season curve |\n", + "| `trough` | trough / base value (the curve minimum) |\n", + "| `mos` | middle of season (DOY midpoint between SOS and EOS) |\n", + "\n", + "**`extraction`** chooses how SOS/EOS are located — the four methods can give very\n", + "different DOYs on the *same* curve (see the printout):\n", + "\n", + "- `seasonal_median` — historical default; median DOY of the green-up / senescing\n", + " phase around the peak.\n", + "- `trs` — relative-amplitude **threshold** (default 50 %); pass\n", + " `extract_params={\"threshold\": 0.2}` for 20 %.\n", + "- `der` — **derivative**: SOS/EOS at the maximum greening / senescence rate.\n", + "- `curvature` — **inflection**: SOS/EOS at the maximum curvature on each side.\n", + "\n", + "Method-specific options go through **`extract_params`**, mirroring `recon_params`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b05a144b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:16.482899Z", + "iopub.status.busy": "2026-05-26T22:13:16.482790Z", + "iopub.status.idle": "2026-05-26T22:13:16.645092Z", + "shell.execute_reply": "2026-05-26T22:13:16.644658Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['sos', 'pos', 'eos', 'vsos', 'vpos', 'veos', 'los', 'msp', 'mau', 'vmsp', 'vmau', 'ampl', 'ios', 'rog', 'ros', 'sw', 'trough', 'mos']\n" + ] + } + ], + "source": [ + "lsp = shape.pheno.PhenoLSP()\n", + "print(list(lsp.data_vars))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c05919ab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:16.646227Z", + "iopub.status.busy": "2026-05-26T22:13:16.646114Z", + "iopub.status.idle": "2026-05-26T22:13:17.479505Z", + "shell.execute_reply": "2026-05-26T22:13:17.479008Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "curvature median SOS= 40 median EOS= 339\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "der median SOS= 283 median EOS= 361\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "seasonal_median median SOS= 241 median EOS= 339\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trs median SOS= 1 median EOS= 361\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "extract_params OK\n" + ] + } + ], + "source": [ + "for extraction in list_extractors():\n", + " l = shape.pheno.PhenoLSP(extraction=extraction)\n", + " print(f\"{extraction:16s} median SOS={float(l['sos'].median()):5.0f} median EOS={float(l['eos'].median()):5.0f}\")\n", + "_ = shape.pheno.PhenoLSP(extraction=\"trs\", extract_params={\"threshold\": 0.2})\n", + "print(\"extract_params OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "17deddb9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:17.480729Z", + "iopub.status.busy": "2026-05-26T22:13:17.480620Z", + "iopub.status.idle": "2026-05-26T22:13:17.770456Z", + "shell.execute_reply": "2026-05-26T22:13:17.769954Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(13, 3.5))\n", + "for ax, m in zip(axes, [\"sos\", \"pos\", \"eos\"]):\n", + " lsp[m].plot(ax=ax); ax.set_title(m.upper())\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "20967923", + "metadata": {}, + "source": [ + "## 4. Goodness of fit — `RMSE`\n", + "\n", + "`RMSE` measures, per pixel, how well the reconstructed curve matches the original\n", + "observations — use it to compare reconstruction methods or flag poorly-fit pixels.\n", + "\n", + "- **`normalized=True`** → nRMSE (RMSE ÷ value range), comparable across pixels and\n", + " indices.\n", + "- **`segment=True`** → splits the error by phenophase, adding `rmse_sos`,\n", + " `rmse_pos`, `rmse_eos` next to the overall `rmse`, showing *where* in the season\n", + " the fit struggles (it reads the breakpoints from the `LSP_stack` you pass in)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1e01b6d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:17.771643Z", + "iopub.status.busy": "2026-05-26T22:13:17.771537Z", + "iopub.status.idle": "2026-05-26T22:13:17.921452Z", + "shell.execute_reply": "2026-05-26T22:13:17.920937Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overall nRMSE (mean): 0.06927432388897184\n", + "segmented variables : ['rmse', 'rmse_sos', 'rmse_pos', 'rmse_eos']\n" + ] + } + ], + "source": [ + "rmse = shape.pheno.RMSE(sif, LSP_stack=lsp, normalized=True)\n", + "print(\"overall nRMSE (mean):\", float(rmse[\"rmse\"].mean()))\n", + "seg = shape.pheno.RMSE(sif, LSP_stack=lsp, normalized=True, segment=True)\n", + "print(\"segmented variables :\", list(seg.data_vars))" + ] + }, + { + "cell_type": "markdown", + "id": "5cbd4dab", + "metadata": {}, + "source": [ + "## 5. Curvature — `get_curvature` / `classify_vector_numeric`\n", + "\n", + "`classify_vector_numeric(v)` reduces a curve to a single number — the **sum of its\n", + "second differences** (`np.sum(np.diff(v, n=2))`), a coarse measure of overall\n", + "concavity. `get_curvature` applies it across the `doy` axis to produce **one value\n", + "per pixel** `(y, x)`: a map of how strongly curved (vs. flat/linear) each pixel's\n", + "seasonal shape is. *(This whole-season summary is distinct from the finer\n", + "`curvature` extractor in §3, which uses the second derivative to locate SOS/EOS.)*" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b734c07e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:17.923026Z", + "iopub.status.busy": "2026-05-26T22:13:17.922787Z", + "iopub.status.idle": "2026-05-26T22:13:18.018681Z", + "shell.execute_reply": "2026-05-26T22:13:18.018158Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "classify_vector_numeric (central pixel): -0.19955235347151756\n" + ] + } + ], + "source": [ + "curv = get_curvature(shape)\n", + "curv.plot(); plt.title(\"Phenological curvature\"); plt.show()\n", + "print(\"classify_vector_numeric (central pixel):\",\n", + " float(classify_vector_numeric(shape.isel(y=ys, x=xs).values)))" + ] + }, + { + "cell_type": "markdown", + "id": "8628f5da", + "metadata": {}, + "source": [ + "## 6. Number of seasons — `n_seasons` (NOS)\n", + "\n", + "`n_seasons` counts the **growing cycles per pixel** (NOS, *Number Of Seasons*) by\n", + "detecting peaks of the reconstructed `PhenoShape` curve with\n", + "`scipy.signal.find_peaks`. It separates single-cycle vegetation (NOS = 1) from\n", + "**multi-cropping / bimodal** systems (NOS ≥ 2), e.g. double-cropped cereals.\n", + "\n", + "What makes a peak count:\n", + "- **`prominence`** (default `0.1`) — a peak must stand at least this fraction of\n", + " the pixel's amplitude (max − min) above its surroundings. This is the main noise\n", + " filter: raise it to keep only the strong seasons, lower it to be more permissive.\n", + "- **`distance`** — optional minimum spacing between peaks, in samples of the `doy`\n", + " grid (forbid peaks closer than, say, ~2 months).\n", + "- **`min_height`** — optional minimum peak height, as a fraction of amplitude above\n", + " the trough.\n", + "\n", + "Edge cases: a flat curve (amplitude ≤ 0) → `0`; fewer than 3 finite values → `NaN`.\n", + "The output is a per-pixel `(y, x)` count. The bundled samples are largely\n", + "single-season, so this mostly returns `1` here — see §14 for the data needed to\n", + "exercise NOS ≥ 2." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "435de683", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:18.020092Z", + "iopub.status.busy": "2026-05-26T22:13:18.019978Z", + "iopub.status.idle": "2026-05-26T22:13:18.125203Z", + "shell.execute_reply": "2026-05-26T22:13:18.124734Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "season counts present: [0. 1. 2. 3. 4.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nos = n_seasons(shape, prominence=0.1)\n", + "print(\"season counts present:\", np.unique(nos.values[np.isfinite(nos.values)]))\n", + "nos.plot(); plt.title(\"Number of seasons\"); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "46e42787", + "metadata": {}, + "source": [ + "## 7. Southern-Hemisphere reordering — `reorder_southern_hemisphere`\n", + "\n", + "SIF is over Chile: the austral growing season peaks around the calendar-year\n", + "boundary (Dec–Feb), so on a normal day-of-year axis it is **split** across DOY\n", + "365/1. `reorder_southern_hemisphere` re-sorts the time steps to start the\n", + "\"season\" in July and **re-labels `doy` as a day-of-season index — still 1–365,\n", + "but starting mid-year** — so the season becomes contiguous and centred.\n", + "\n", + "That is why the middle panel below still spans 1–365: it is *day of season*,\n", + "not calendar day. To put the *real* Southern-Hemisphere calendar DOY\n", + "(…183, 365, 1, 182…) back on the axis, use `plot_with_southern_doy` on the\n", + "reordered shape. (Run on a 2-year slice for speed.)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5a082446", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:18.126505Z", + "iopub.status.busy": "2026-05-26T22:13:18.126389Z", + "iopub.status.idle": "2026-05-26T22:13:18.348877Z", + "shell.execute_reply": "2026-05-26T22:13:18.348375Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reordered DOY positions: 92\n" + ] + } + ], + "source": [ + "from phenosensing.plotting import plot_with_southern_doy\n", + "\n", + "sif_2y = sif.isel(time=slice(0, 92))\n", + "positions, sif_sh = reorder_southern_hemisphere(sif_2y)\n", + "sh_shape = sif_sh.pheno.PhenoShape()\n", + "\n", + "# Before/after: calendar DOY splits the austral peak; reordering centres it.\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4), sharey=True)\n", + "sif_2y.pheno.PhenoShape().isel(y=ys, x=xs).plot(ax=axes[0])\n", + "axes[0].set_title(\"calendar DOY (peak split near New Year)\")\n", + "sh_shape.isel(y=ys, x=xs).plot(ax=axes[1])\n", + "axes[1].set_title(\"reordered: day-of-season axis (peak centred)\")\n", + "plt.tight_layout(); plt.show()\n", + "\n", + "# Same reordered curve, x-axis re-labelled to the real SH calendar DOY\n", + "try:\n", + " plot_with_southern_doy(sh_shape, (float(sif.x[xs]), float(sif.y[ys])),\n", + " ylabel=\"SIF\", title=\"Real Southern-Hemisphere calendar DOY\")\n", + " plt.show()\n", + "except Exception as e:\n", + " print(\"plot_with_southern_doy:\", type(e).__name__, e)\n", + "print(\"reordered DOY positions:\", len(positions))" + ] + }, + { + "cell_type": "markdown", + "id": "7f9c082d", + "metadata": {}, + "source": [ + "## 8. Interannual time series — `get_timeseries_metrics`\n", + "\n", + "This is the **temporal axis**, and PhenoSensing's signature feature. Instead of pooling\n", + "all years into one climatology, it slides a **moving multi-year window** over the\n", + "series: for each window it runs the full reconstruct → extract pipeline and records\n", + "every metric, producing a *time series* of each LSP metric (one value per window\n", + "step). That series is what feeds the trend in §9. Run on a small spatial subset\n", + "here for speed.\n", + "\n", + "- **`window_length`** — number of years pooled per step (e.g. `3`); `1` gives a\n", + " per-year estimate.\n", + "- **`metric`** — `\"all\"` or a subset, e.g. `[\"sos\", \"pos\", \"eos\"]`.\n", + "- **`interpolType` / `recon_params` / `extraction` / `extract_params`** — the same\n", + " axis-1 and axis-3 knobs as `PhenoShape` / `PhenoLSP`, applied inside every window.\n", + "\n", + "Returns a `dict` of `(time, y, x)` `DataArray`s, one per requested metric." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1f2eb46a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:18.350029Z", + "iopub.status.busy": "2026-05-26T22:13:18.349916Z", + "iopub.status.idle": "2026-05-26T22:13:18.934098Z", + "shell.execute_reply": "2026-05-26T22:13:18.933668Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'sos': {'time': 18, 'y': 4, 'x': 4}, 'pos': {'time': 18, 'y': 4, 'x': 4}, 'eos': {'time': 18, 'y': 4, 'x': 4}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sif_small = sif.isel(y=slice(ys - 2, ys + 2), x=slice(xs - 2, xs + 2))\n", + "ts = sif_small.pheno.get_timeseries_metrics(window_length=3, metric=[\"sos\", \"pos\", \"eos\"], nGS=40)\n", + "print({k: dict(v.sizes) for k, v in ts.items()})\n", + "ts[\"sos\"].mean(dim=[\"y\", \"x\"]).plot(marker=\"o\")\n", + "plt.title(\"Mean SOS over time (3-year moving window)\"); plt.ylabel(\"SOS (DOY)\"); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3e709f78", + "metadata": {}, + "source": [ + "## 9. Trends — `trend` (Theil–Sen slope + Mann–Kendall)\n", + "\n", + "`trend` fits a **robust** per-pixel temporal trend to any metric series from §8\n", + "(or any `(time, y, x)` array). It returns a `Dataset` with:\n", + "\n", + "- **`slope`** — the **Theil–Sen** estimator (median of pairwise slopes), in metric\n", + " units per time step; robust to outliers. For `sos`, a negative slope means the\n", + " season is starting *earlier* over time.\n", + "- **`p_value`** — the two-sided **Mann–Kendall** significance (a non-parametric\n", + " monotonic-trend test).\n", + "\n", + "Pixels with fewer than four finite time steps return `NaN`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2897c37c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:18.935253Z", + "iopub.status.busy": "2026-05-26T22:13:18.935132Z", + "iopub.status.idle": "2026-05-26T22:13:19.144013Z", + "shell.execute_reply": "2026-05-26T22:13:19.143649Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "slope range (DOY/step): -1.125 0.6923076923076923\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sos_trend = trend(ts[\"sos\"])\n", + "print(\"slope range (DOY/step):\", float(sos_trend[\"slope\"].min()), float(sos_trend[\"slope\"].max()))\n", + "fig, axes = plt.subplots(1, 2, figsize=(9, 3.5))\n", + "sos_trend[\"slope\"].plot(ax=axes[0]); axes[0].set_title(\"SOS Theil-Sen slope\")\n", + "sos_trend[\"p_value\"].plot(ax=axes[1]); axes[1].set_title(\"Mann-Kendall p-value\")\n", + "plt.tight_layout(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0f399c3a", + "metadata": {}, + "source": [ + "## 10. Anomalies — `anomaly` (npphen-style RFD)\n", + "\n", + "`anomaly` compares each observation against the pixel's **climatological**\n", + "`PhenoShape`: it interpolates the expected value at every observation's DOY and\n", + "measures the departure from it. Returns a `Dataset` with:\n", + "\n", + "- **`anomaly`** — observed − expected, in index units.\n", + "- **`rfd`** — the empirical percentile (RFD) of each anomaly within the pixel's own\n", + " distribution, in (0, 1]; npphen-style.\n", + "- **`z`** — the standardized anomaly (when `standardize=True`).\n", + "\n", + "Pass **`reference=`** a held-out cube to score a target period against an\n", + "independent climatology; `interpolType=\"KDE\"` builds a fully non-parametric\n", + "reference. (Here it self-references the 20-year SIF.)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "01db325c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:19.145373Z", + "iopub.status.busy": "2026-05-26T22:13:19.145264Z", + "iopub.status.idle": "2026-05-26T22:13:19.396904Z", + "shell.execute_reply": "2026-05-26T22:13:19.396468Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variables: ['anomaly', 'rfd', 'z']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "an = anomaly(sif_small, nGS=40)\n", + "print(\"variables:\", list(an.data_vars))\n", + "an[\"rfd\"].isel(time=-1).plot(); plt.title(\"RFD of the last observation\"); plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "85e0ec07", + "metadata": {}, + "source": [ + "## 11. Per-metric uncertainty — `uncertainty` (bootstrap)\n", + "\n", + "`uncertainty` estimates how stable each LSP metric is to sampling noise: it\n", + "**bootstraps** the per-pixel observations `n_boot` times, recomputes the 16 metrics\n", + "on each resample, and returns the **standard deviation** of each metric per pixel\n", + "(`(y, x)` per variable). Larger values flag metrics/pixels whose timing or\n", + "magnitude is poorly constrained by the available observations.\n", + "\n", + "- **`n_boot`** — number of bootstrap replicates (default 50).\n", + "- **`interpolType` / `rollWindow` / `nGS` / `extraction` / `extract_params`** — the\n", + " same pipeline knobs, applied to every replicate.\n", + "- **`seed`** — makes the resampling reproducible." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b81830e5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:19.398289Z", + "iopub.status.busy": "2026-05-26T22:13:19.398173Z", + "iopub.status.idle": "2026-05-26T22:13:19.593621Z", + "shell.execute_reply": "2026-05-26T22:13:19.593171Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean SOS uncertainty (std, days): 52.690804515074525\n" + ] + } + ], + "source": [ + "unc = uncertainty(sif_small, n_boot=20, nGS=40)\n", + "print(\"mean SOS uncertainty (std, days):\", float(unc[\"sos\"].mean()))" + ] + }, + { + "cell_type": "markdown", + "id": "a34d84a3", + "metadata": {}, + "source": [ + "## 12. Performance — chunking / out-of-core + Numba\n", + "\n", + "`PhenoShape` is built on `xr.apply_ufunc(dask=\"parallelized\")`, so passing\n", + "**`chunks=`** returns a lazy, **Dask-backed** result that computes tile-by-tile —\n", + "the same numbers as the eager path, but without holding the whole cube in memory\n", + "(verified below). For the in-memory **linear** path it also uses a **Numba** kernel\n", + "(`[fast]` extra) for a large speed-up. **`computeChunkSize`** suggests a tile shape\n", + "bounded by a target size in MB." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c8579687", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:19.594945Z", + "iopub.status.busy": "2026-05-26T22:13:19.594842Z", + "iopub.status.idle": "2026-05-26T22:13:19.828513Z", + "shell.execute_reply": "2026-05-26T22:13:19.828056Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "suggested chunks (~5 MB): {'time': 920, 'y': 17, 'x': 20}\n", + "dask-backed : True\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "chunked == eager: True\n" + ] + } + ], + "source": [ + "from phenosensing.utils import computeChunkSize\n", + "print(\"suggested chunks (~5 MB):\", computeChunkSize(sif, sizeMB=5))\n", + "lazy = sif.pheno.PhenoShape(chunks={\"x\": 10, \"y\": 10})\n", + "print(\"dask-backed :\", dask.is_dask_collection(lazy.data))\n", + "print(\"chunked == eager:\", bool(np.allclose(lazy.compute().values, shape.values, equal_nan=True)))" + ] + }, + { + "cell_type": "markdown", + "id": "e2e100c8", + "metadata": {}, + "source": [ + "## 13. Plotting helpers\n", + "\n", + "`PhenoPlot` overlays the **per-year observations** on the fitted curve for one\n", + "pixel — a quick visual check of the reconstruction and of interannual spread.\n", + "\n", + "- **`southern=True`** re-labels the x-axis to Southern-Hemisphere day-of-year so\n", + " the austral season is centred (continuous across the calendar-year boundary).\n", + "- with **more than `many_years`** years it switches from a per-year legend to a\n", + " continuous **palette + colorbar** (as for the 20-year SIF below).\n", + "\n", + "`display_map` returns an interactive `folium` map of the data's bounding box\n", + "(needs the `[plot]` extra: folium, pyproj)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9047777c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:19.829880Z", + "iopub.status.busy": "2026-05-26T22:13:19.829770Z", + "iopub.status.idle": "2026-05-26T22:13:19.949635Z", + "shell.execute_reply": "2026-05-26T22:13:19.949132Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from phenosensing.plotting import PhenoPlot, display_map\n", + "try:\n", + " # SIF spans 20 years -> continuous palette + colorbar; southern=True centres the austral season\n", + " PhenoPlot(sif, X=float(sif.x[xs]), Y=float(sif.y[ys]), rollWindow=5, ylab=\"SIF\", southern=True)\n", + " plt.show()\n", + "except Exception as e:\n", + " print(\"PhenoPlot:\", type(e).__name__, e)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "08d58735", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-26T22:13:19.950746Z", + "iopub.status.busy": "2026-05-26T22:13:19.950637Z", + "iopub.status.idle": "2026-05-26T22:13:20.070722Z", + "shell.execute_reply": "2026-05-26T22:13:20.070202Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "display_map -> folium.Map created (interactive; renders in a live notebook)\n" + ] + } + ], + "source": [ + "try:\n", + " m = display_map((float(sif.x.min()), float(sif.x.max())),\n", + " (float(sif.y.min()), float(sif.y.max())))\n", + " print(\"display_map -> folium.Map created (interactive; renders in a live notebook)\")\n", + "except Exception as e:\n", + " print(\"display_map needs the [plot] extra (folium, pyproj):\", type(e).__name__, e)" + ] + }, + { + "cell_type": "markdown", + "id": "3eb536fd", + "metadata": {}, + "source": [ + "## 14. What the bundled data cannot cover (and data needed)\n", + "\n", + "The two bundled rasters are small and clean, so some capabilities can only be\n", + "*demonstrated* here, not stress-tested. To fully validate:\n", + "\n", + "- **Large-scale / out-of-core performance.** The samples are tiny\n", + " (≤ 920 × 17 × 20). Benchmarking Dask out-of-core and the Numba kernel at scale\n", + " needs a large multi-tile stack (regional/continental MODIS/Landsat/Sentinel\n", + " NDVI–EVI, GB-sized). The repo's `kndvi_186.tif` (57 × 48, 397 bands) is bigger\n", + " but ships **without a matching date file** (`dates.txt` has 798 entries ≠ 397\n", + " bands) — supply its acquisition dates to use it.\n", + "- **Northern-Hemisphere phenology.** Both samples are mid/low-latitude and SIF\n", + " is Southern Hemisphere. Contrasting `reorder_southern_hemisphere` against a\n", + " clean single-peaked NH season needs a Northern-Hemisphere NDVI/EVI series\n", + " (e.g. a temperate deciduous forest).\n", + "- **Multi-cropping / bimodal seasons.** The samples are largely single-season,\n", + " so `n_seasons` mostly returns 1. Validating NOS ≥ 2 needs a double-cropping\n", + " region (e.g. irrigated cereals/rice with two cycles per year).\n", + "- **Noise robustness & QA weighting.** The samples are fairly clean.\n", + " Stress-testing the robust smoothers (Whittaker / Savitzky-Golay /\n", + " double-logistic) and the *planned* QA-weighting feature needs raw,\n", + " cloud-contaminated optical data **with a per-observation quality band**\n", + " (MODIS MOD13 pixel-reliability, or Landsat/Sentinel-2 SCL/Fmask).\n", + "- **Anomaly skill against an independent reference.** `anomaly(target,\n", + " reference=...)` is best validated with a held-out climatology and a\n", + " *documented extreme year* (e.g. a known drought). The 20-year SIF supports a\n", + " self-reference demo only.\n", + "- **Cross-sensor / harmonised series** (e.g. HLS Landsat + Sentinel-2) are out\n", + " of scope of the samples but needed to test robustness across sensors.\n", + "\n", + "**Not yet implemented (so not testable here):** QA/weight-updating\n", + "reconstruction and the extra metrics (explicit trough/base, middle-of-season).\n", + "Both are on the roadmap; once added they need the QA-band data above and a\n", + "refresh of the golden regression fixtures.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "PhenoPY", + "language": "python", + "name": "phenopy" + }, + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..b1e2f1f --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,43 @@ +site_name: PhenoSensing +site_description: Land surface phenology metrics from satellite image time series +repo_url: https://github.com/JavierLopatin/PhenoSensing +repo_name: JavierLopatin/PhenoSensing + +theme: + name: material + palette: + - scheme: default + primary: green + toggle: + icon: material/weather-night + name: Switch to dark mode + - scheme: slate + primary: green + toggle: + icon: material/weather-sunny + name: Switch to light mode + features: + - navigation.sections + - content.code.copy + +plugins: + - search + - mkdocstrings: + handlers: + python: + options: + show_root_heading: true + show_source: true + members_order: source + +nav: + - Home: index.md + - Installation: installation.md + - Quickstart: quickstart.md + - Performance: performance.md + - API reference: api.md + +markdown_extensions: + - admonition + - pymdownx.highlight + - pymdownx.superfences diff --git a/phenopy/.ipynb_checkpoints/ExampleData-checkpoint.ipynb b/phenopy/.ipynb_checkpoints/ExampleData-checkpoint.ipynb deleted file mode 100644 index c504c86..0000000 --- a/phenopy/.ipynb_checkpoints/ExampleData-checkpoint.ipynb +++ /dev/null @@ -1,3609 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# PhenoPY\n", - "

\n", - "\n", - "\n", - "

Python bindings for Phenological analysis of Remote Sensing data

\n", - "\n", - "

\n", - " \n", - " \"Gitter\"\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "

\n", - "\n", - "### Library dependencies:\n", - "- Python < 3.6\n", - "- rasterstats\n", - "- rasterio\n", - "- xarrar\n", - "- rioxarray\n", - "- shapely\n", - "- pandas\n", - "- numpy\n", - "- scipy\n", - "- matplotlib\n", - "- tqdm\n", - "\n", - "\n", - "### Documentation comming soon...\n", - "\n", - "### Exampe:\n", - "\n", - "Monthly tome series data of SIF (satellite-retrieved solar-induced chlorophyll fluorescence) depicted from Chen et al. (2022; https://www.nature.com/articles/s41597-022-01520-1). The area here is a small sample for Chile." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import sys, os\n", - "import xarray as xr\n", - "import rioxarray as rio\n", - "import geopandas as gpd\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "\n", - "# PhenoPy modules\n", - "from phenopy import Pheno\n", - "from plotting import plot_with_southern_doy, PhenoPlot\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 2001-01-01\n", - "1 2001-01-09\n", - "2 2001-01-17\n", - "3 2001-01-25\n", - "4 2001-02-02\n", - "Name: 0, dtype: datetime64[ns]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# load time data corresponding to the time serie data\n", - "days = 'data/SIF_sample_dates.csv'\n", - "dates = pd.read_csv(days, header=None)[0]\n", - "dates = pd.to_datetime(dates)\n", - "dates.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray (time: 920, y: 17, x: 20)>\n",
-       "[312800 values with dtype=float32]\n",
-       "Coordinates:\n",
-       "  * time         (time) datetime64[ns] 2001-01-01 2001-01-09 ... 2020-12-26\n",
-       "  * x            (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n",
-       "  * y            (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n",
-       "    spatial_ref  int64 0\n",
-       "    doy          (time) int64 1 9 17 25 33 41 49 ... 313 321 329 337 345 353 361\n",
-       "    year         (time) int64 2001 2001 2001 2001 2001 ... 2020 2020 2020 2020\n",
-       "Attributes:\n",
-       "    _FillValue:    -3.3999999521443642e+38\n",
-       "    scale_factor:  1.0\n",
-       "    add_offset:    0.0
" - ], - "text/plain": [ - "\n", - "[312800 values with dtype=float32]\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 2001-01-01 2001-01-09 ... 2020-12-26\n", - " * x (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n", - " * y (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n", - " spatial_ref int64 0\n", - " doy (time) int64 1 9 17 25 33 41 49 ... 313 321 329 337 345 353 361\n", - " year (time) int64 2001 2001 2001 2001 2001 ... 2020 2020 2020 2020\n", - "Attributes:\n", - " _FillValue: -3.3999999521443642e+38\n", - " scale_factor: 1.0\n", - " add_offset: 0.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inData = 'data/SIF_sample.tif'\n", - "img = rio.open_rasterio(inData)\n", - "\n", - "# Check if img is an xarray DataArray\n", - "if not hasattr(img, 'assign_coords'):\n", - " raise ValueError(\"img is not an xarray DataArray\")\n", - "\n", - "# Check if dates is defined\n", - "if 'dates' not in locals():\n", - " raise ValueError(\"dates variable is not defined\")\n", - "\n", - "# Change 'band' dim to 'time' and assign time values to xarray dimension\n", - "img = img.rename({'band': 'time'}).assign_coords(time=dates.values)\n", - "# Assign day of year and year\n", - "img['doy'] = img.time.dt.dayofyear\n", - "img['year'] = img.time.dt.year\n", - "\n", - "img" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "img.isel(time=0).plot(robust=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'SIF [$Wm^{-2}nm^{-1}sr^{-1}$]')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "img.isel(x=5, y=5).plot.line('b-^', figsize=(11,4))\n", - "plt.title('SIF timeseries')\n", - "plt.ylabel('SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'SIF [$Wm^{-2}nm^{-1}sr^{-1}$]')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot one year time series\n", - "img.where(img.year == 2017, drop=True).isel(x=5, y=5).plot.line('b-^', figsize=(11,4))\n", - "plt.ylabel('SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'SIF [$Wm^{-2}nm^{-1}sr^{-1}$]')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot one year time series by doy\n", - "img.where(img.year == 2017, drop=True).isel(x=5, y=5).plot.line('b-^', x='doy', figsize=(11,4))\n", - "plt.ylabel('SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As you can see, if you take only yearly data you may end up with many gaps in the data. So, if you are interested in stable land surface phenology (LSP) metrics, you may want to mix several years together to fill the gaps with other years information:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Use the PhenoPlot funtion with an example X, Y coordinates to play with interpolation parameters.\n", - "\n", - "X = np.median(img.x.values)\n", - "Y = np.median(img.y.values)\n", - "\n", - "PhenoPlot(img, X, Y, interpolType='linear', rollWindow=5, plotType=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we are in the souther hemosphere in this case, the typical order of DOY does not give us the necesary phenological shape for rstimating Land Surface Phenology (LSP) metrics.\n", - "\n", - "Hence, we can create pseudo-DOYs for fitting the necesary data and then correct for the real DOY values when plotting." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray (time: 920, y: 17, x: 20)>\n",
-       "[312800 values with dtype=float32]\n",
-       "Coordinates:\n",
-       "  * time         (time) datetime64[ns] 2001-07-04 2002-07-04 ... 2020-06-25\n",
-       "  * x            (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n",
-       "  * y            (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n",
-       "    spatial_ref  int64 0\n",
-       "    doy          (time) int64 1 1 1 1 1 1 1 1 ... 361 361 361 361 361 361 361\n",
-       "    year         (time) int64 2001 2002 2003 2004 2005 ... 2017 2018 2019 2020\n",
-       "Attributes:\n",
-       "    _FillValue:    -3.3999999521443642e+38\n",
-       "    scale_factor:  1.0\n",
-       "    add_offset:    0.0
" - ], - "text/plain": [ - "\n", - "[312800 values with dtype=float32]\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 2001-07-04 2002-07-04 ... 2020-06-25\n", - " * x (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n", - " * y (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n", - " spatial_ref int64 0\n", - " doy (time) int64 1 1 1 1 1 1 1 1 ... 361 361 361 361 361 361 361\n", - " year (time) int64 2001 2002 2003 2004 2005 ... 2017 2018 2019 2020\n", - "Attributes:\n", - " _FillValue: -3.3999999521443642e+38\n", - " scale_factor: 1.0\n", - " add_offset: 0.0" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "### Change the DOY order for southern hemisphere\n", - "\n", - "from utils import reorder_southern_hemisphere\n", - "\n", - "reordered_doy, south_img = reorder_southern_hemisphere(img)\n", - "south_img" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'SIF timeseries in the southern hemisphere with pseudo-doy')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot one year time series by doy in the reordered dataset for southern hemisphere\n", - "south_img.where(south_img.year == 2017, drop=True).isel(x=5, y=5).plot.line('b-^', x='doy', figsize=(11,4))\n", - "plt.ylabel('SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')\n", - "plt.title('SIF timeseries in the southern hemisphere with pseudo-doy')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can estimate an interannual phenological shape using all year and heve summer time in the middle of the season.\n", - "\n", - "Using multi-year data, PhenoPy is able to fill the gaps and fit a single phenological shape from which estimate phenological parameters, such as the start of the season (SOS), the peak of season (POS), and the end of season (EOS). You can check if these values are correctly assessed by using type=2 in PhenoPlot:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "### TODO: FIX PLOTTING OF DOTS (YEARS) AND INTERPOLATION\n", - "\n", - "# test model parameter using a 2D plot\n", - "\n", - "# example coordinates for testing\n", - "X = np.median(img.x.values)\n", - "Y = np.median(img.y.values)\n", - "\n", - "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "PhenoPlot(south_img, X, Y, 'linear', rollWindow=5,\n", - " plotType=1, ax=axes[0], ylab='SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')\n", - "\n", - "PhenoPlot(south_img, X, Y, 'linear', rollWindow=5,\n", - " plotType=2, ax=axes[1], ylab='SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')\n", - "\n", - "axes[0].set_title(\"Plot all observations\")\n", - "axes[1].set_title(\"Plot SOS, POS, and EOS estimations\")\n", - "\n", - "# Display the plots\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Estimate Phenological shape to the raster using the same parameters. Here we are using weekly interpolations (nGS=52), linear interpolation and a rollWindow of 5 for smoothing." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# PhenoShape\n", - "shape = img.pheno.PhenoShape(rollWindow=5)\n", - "shape_south = south_img.pheno.PhenoShape(rollWindow=5)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot with selected xy coordinates and use the closest real values if the selected xy is not in the original data\n", - "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "shape.sel(x=X, y=Y, method=\"nearest\").plot(ax=axes[0])\n", - "shape_south.sel(x=X, y=Y, method=\"nearest\").plot(ax=axes[1])\n", - "\n", - "axes[0].set_title(\"Without changing hemisphere\")\n", - "axes[1].set_title(\"Changing hemisphere\")\n", - "\n", - "# Display the plots\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# reorder xlabels for southern hemisphere\n", - "plot_with_southern_doy(shape_south, coordinates=[X,Y], ylabel='SIF ['r'$Wm^{-2}nm^{-1}sr^{-1}$]')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can estimate the LSP metrics for the raster. Until now, the metrics included are:\n", - "\n", - "SOS - DOY of Start of season \\\n", - "POS - DOY of Peak of season \\\n", - "EOS - DOY of End of season \\\n", - "vSOS - Vaues at start os season \\\n", - "vPOS - Values at peak of season \\\n", - "vEOS - Values at end of season \\\n", - "LOS - Length of season \\\n", - "MSP - Mid spring (DOY) \\\n", - "MAU - Mid autum (DOY) \\\n", - "vMSP - Value at mean spring \\\n", - "vMAU - Value at mean autum \\\n", - "AOS - Amplitude of season \\\n", - "IOS - Integral of season [SOS-EOS] \\\n", - "ROG - Rate of greening [slope SOS-POS] \\\n", - "ROS - Rate of senescence [slope POS-EOS] \\\n", - "SW - Skewness of growing season [SOS-EOS]" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:  (y: 17, x: 20)\n",
-       "Coordinates:\n",
-       "  * y        (y) float64 -37.63 -37.68 -37.73 -37.78 ... -38.33 -38.38 -38.43\n",
-       "  * x        (x) float64 -73.02 -72.97 -72.92 -72.87 ... -72.17 -72.12 -72.07\n",
-       "Data variables: (12/16)\n",
-       "    sos      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    pos      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    eos      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    vsos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    vpos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    veos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    ...       ...\n",
-       "    vmau     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    ampl     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    ios      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    rog      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    ros      (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    sw       (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>
" - ], - "text/plain": [ - "\n", - "Dimensions: (y: 17, x: 20)\n", - "Coordinates:\n", - " * y (y) float64 -37.63 -37.68 -37.73 -37.78 ... -38.33 -38.38 -38.43\n", - " * x (x) float64 -73.02 -72.97 -72.92 -72.87 ... -72.17 -72.12 -72.07\n", - "Data variables: (12/16)\n", - " sos (y, x) float64 dask.array\n", - " pos (y, x) float64 dask.array\n", - " eos (y, x) float64 dask.array\n", - " vsos (y, x) float64 dask.array\n", - " vpos (y, x) float64 dask.array\n", - " veos (y, x) float64 dask.array\n", - " ... ...\n", - " vmau (y, x) float64 dask.array\n", - " ampl (y, x) float64 dask.array\n", - " ios (y, x) float64 dask.array\n", - " rog (y, x) float64 dask.array\n", - " ros (y, x) float64 dask.array\n", - " sw (y, x) float64 dask.array" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Land surface phenology metrics (LSP)\n", - "lsp = shape_south.pheno.PhenoLSP()\n", - "lsp" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot lsp.sos.plot(robust=True) and lsp.eos.plot(robust=True) in the same figure\n", - "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "lsp.sos.plot(ax=axes[0], robust=True)\n", - "lsp.eos.plot(ax=axes[1], robust=True)\n", - "\n", - "axes[0].set_title(\"SOS\")\n", - "axes[1].set_title(\"EOS\")\n", - "\n", - "# Display the plots\n", - "plt.show() \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also estimate the interannual variability of the phenological metrics by calculating the root mean square error of the sognal.\n", - "\n", - "See Lopatin (2023; https://ieeexplore.ieee.org/document/10128132).\n", - "\n", - "E.g., \n", - "\n", - "\"\"" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:      (x: 20, y: 17)\n",
-       "Coordinates:\n",
-       "  * x            (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n",
-       "  * y            (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n",
-       "    spatial_ref  int64 0\n",
-       "Data variables:\n",
-       "    rmse         (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    rmse_sos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    rmse_pos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>\n",
-       "    rmse_eos     (y, x) float64 dask.array<chunksize=(10, 10), meta=np.ndarray>
" - ], - "text/plain": [ - "\n", - "Dimensions: (x: 20, y: 17)\n", - "Coordinates:\n", - " * x (x) float64 -73.02 -72.97 -72.92 ... -72.17 -72.12 -72.07\n", - " * y (y) float64 -37.63 -37.68 -37.73 ... -38.33 -38.38 -38.43\n", - " spatial_ref int64 0\n", - "Data variables:\n", - " rmse (y, x) float64 dask.array\n", - " rmse_sos (y, x) float64 dask.array\n", - " rmse_pos (y, x) float64 dask.array\n", - " rmse_eos (y, x) float64 dask.array" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rmse = shape.pheno.RMSE(img, LSP_stack=lsp, normalized=True)\n", - "rmse2 = shape.pheno.RMSE(img, LSP_stack=lsp, normalized=False)\n", - "rmse" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "rmse.rmse.plot(ax=axes[0], robust=True)\n", - "rmse2.rmse.plot(ax=axes[1], robust=True)\n", - "\n", - "axes[0].set_title(\"Overall normalized RMSE\")\n", - "axes[1].set_title(\"Overall RMSE\")\n", - "\n", - "# Display the plots\n", - "plt.show() " - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot lsp.sos.plot(robust=True) and lsp.eos.plot(robust=True) in the same figure\n", - "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(16, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "rmse.rmse_sos.plot(ax=axes[0], robust=True)\n", - "rmse.rmse_pos.plot(ax=axes[1], robust=True)\n", - "rmse.rmse_eos.plot(ax=axes[2], robust=True)\n", - "\n", - "axes[0].set_title(\"RMSE_SOS\")\n", - "axes[1].set_title(\"RMSE_POS\")\n", - "axes[2].set_title(\"RMSE_EOS\")\n", - "\n", - "# Display the plots\n", - "plt.show() " - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot RMSE RGB-based figure\n", - "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", - "\n", - "# Plot the DataArrays side by side\n", - "rmse.to_array()[[3, 2, 1], :, :].plot.imshow(ax=axes[0], robust=True)\n", - "rmse2.to_array()[[3, 2, 1], :, :].plot.imshow(ax=axes[1], robust=True)\n", - "\n", - "axes[0].set_title(\"Overall normalized RMSE\")\n", - "axes[1].set_title(\"Overall RMSE\")\n", - "\n", - "# Display the plots\n", - "plt.show()" - ] - } - ], - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/phenopy/__pycache__/curvature.cpython-39.pyc b/phenopy/__pycache__/curvature.cpython-39.pyc deleted file mode 100644 index 7e46d29..0000000 Binary files a/phenopy/__pycache__/curvature.cpython-39.pyc and /dev/null differ diff --git a/phenopy/__pycache__/phenopy.cpython-39.pyc b/phenopy/__pycache__/phenopy.cpython-39.pyc deleted file mode 100644 index 60bc33f..0000000 Binary files a/phenopy/__pycache__/phenopy.cpython-39.pyc and /dev/null differ diff --git a/phenopy/__pycache__/plotting.cpython-39.pyc b/phenopy/__pycache__/plotting.cpython-39.pyc deleted file mode 100644 index 5bb0355..0000000 Binary files a/phenopy/__pycache__/plotting.cpython-39.pyc and /dev/null differ diff --git a/phenopy/__pycache__/utils.cpython-39.pyc b/phenopy/__pycache__/utils.cpython-39.pyc deleted file mode 100644 index a27829c..0000000 Binary files a/phenopy/__pycache__/utils.cpython-39.pyc and /dev/null differ diff --git a/phenopy/phenopy.py b/phenopy/phenopy.py deleted file mode 100644 index 62176e1..0000000 --- a/phenopy/phenopy.py +++ /dev/null @@ -1,348 +0,0 @@ -############################################################################### -# -# PhenoPy is a Python 3.X library to process phenology indices derived from -# EarthObservation data. -# -############################################################################### - -# libraries included in Python 3.X -from __future__ import division -import concurrent.futures -from functools import partial -import sys -import warnings - -# common dependencies -import pandas as pd -import numpy as np -import matplotlib.pyplot as plt -from scipy.integrate import trapz -from scipy.interpolate import Rbf, interp1d -from scipy.stats import skew -from sklearn.metrics import mean_squared_error - -# speciel dependencies -import xarray as xr # manipulate 3D time-series rasters -import shapely.geometry as geom # create geographical points -import rasterio # manipulate GeoTIFF -from rasterstats import point_query # extract raster values -from tqdm import tqdm # progress bar -# from kneed import KneeLocator # find inflection point on a curve -# from KDEpy import FFTKDE # perform fast 2D kernel density estimations - -# from PhenoPy - -#import all function from utils.py -from utils import _getPheno0, _getPheno2D, _parseLSP, _getLSPmetrics2, _rmse, _replaceElements -from curvature import get_curvature - - -@xr.register_dataarray_accessor("pheno") -class Pheno: - def __init__(self, xr_obj): - self._obj = xr_obj - self.kwargs = {} - self.LSP_bands = ['sos', 'pos', 'eos', 'vsos', 'vpos', - 'veos', 'los', 'msp', 'mau', 'vmsp', - 'vmau', 'ampl', 'ios', 'rog', 'ros', 'sw'] - - def PhenoShape(self, interpolType='linear', nan_replace=None, - rollWindow=5, nGS=52): - """ - Apply the _getPheno2D/_getPheno2 function to a xarray.DataArray object. It calculates all the necessary auxiliary objects in order to use Dask functionality (trough map_blocks). - - :param doy: day of the year. If not present, it will attempt to extract the doy from the time dimension. - :param interpolType: interpolation type - :param nan_replace: what to do with NaNs - :param rollWindow: rolling window size - :param nGS: number of periods per year, usually 52 (number of weeks in a year) - - :returns: computed xarray.DataArray - """ - stack = self._obj - doy=stack.doy.values - dates=stack.time - years = np.unique(dates.time.dt.year.values) - - # Get the indices that would sort the doy coordinate - #sorted_indices = np.argsort(stack.doy.values) - # Reorder the time dimension using the sorted indices - #stack = stack.isel(time=sorted_indices) - # replicating what happens in _getPheno xnew definition - xnew = np.linspace(np.min(doy), np.max(doy), nGS, dtype=np.int32) - # TODO: change hemisfere, start doy at the desired day (1 north, 182 south) and keep record about the original doy -> dos (day of season) - - # TODO: define a function to auto calculate next chunk (to ~100MB each chunk) - time_chunk = {'x': 300, 'y': 300}# 'time': len(stack.time)} - - coords_ = {'time': xnew, - 'y': stack.coords['y'], - 'x': stack.coords['x']} - template_ = xr.DataArray(np.zeros((nGS, len(stack.y), len(stack.x))), - coords=coords_, - dims = ['time', 'y', 'x']).chunk(time_chunk) - - stack = stack.chunk(time_chunk) - kwargs_ = {'doy': doy, 'interpolType': interpolType, - 'nan_replace': nan_replace, 'rollWindow': rollWindow, - 'nGS': nGS, 'xnew': xnew} - - stackP = stack.map_blocks(_getPheno2D, kwargs=kwargs_, template=template_).rename({'time': 'doy'}) - stackP.pheno.kwargs['computePheno'] = kwargs_ - - return stackP - - def PhenoLSP(self, nGS=None, phentype=1): - """ - Obtain land surface phenology metrics for a PhenoShape product - - Parameters - ---------- - - inData: String - Absolute path to PhenoShape raster data - - outData: String - Absolute path for output land surface phenology raster - - doy: 1D array - Numpy array of the days of the year of the time series - - nGS: Integer - Number of observations to predict the PhenoShape - default is 46; one per week - - phenType: Type os estimation of SOS and EOS. 1 = median value between POS and start and end of season. 2 = using the knee inflexion method. default 1 - - """ - if 'computePheno' not in self.kwargs: - raise('No Pheno computed') # TODO: replace with auto-compute? - - n_ = len(self.LSP_bands) - stack = self._obj - xnew = self.kwargs['computePheno']['xnew'] - time_chunk = [i for i in stack.chunks] - time_chunk[0] = n_ - if nGS is None: - nGS = self.kwargs['computePheno']['nGS'] - - kwargs_ = {'xnew': xnew, 'nGS': nGS, 'bands': self.LSP_bands, 'phentype': phentype} - - coords_ = {'doy': self.LSP_bands, - 'y': stack.coords['y'], - 'x': stack.coords['x']} - template_ = xr.DataArray(np.zeros((n_, len(stack.y), len(stack.x))), - coords=coords_, - dims = ['doy', 'y', 'x']).chunk(time_chunk) - - stackP = stack.map_blocks(_parseLSP, kwargs=kwargs_, template=template_).rename({'doy': 'LSP_bands'}) - stackP.pheno.kwargs['computePhenoLSP'] = kwargs_ # this doesn't work, is not saved, pheno objet its lost in datadaset transformation - - return stackP.to_dataset('LSP_bands') - - def RMSE(self, original_stack, LSP_stack, normalized=False, nan_replace=None, interpolate_nans=False, segment=False): - """ - Calculate the RMSE of the PhenoShape estimation; it can also do it by section, using the sos, pos and eos from the LSP computation (if provided). - - :param original_stack: initial image stack, from which the phenoShape was calculated. - :param LSP_stack: LSP computed stack. - :param normalized: boolean, if True RMSE will be scaled to [0, 1]. - :param nan_replace: values to be converted to NaN. - :param interpolate_nans: boolean, should NaNs values be interpolated? - :param metrics: string, either 'overall' or 'segmented'. If 'overall', the RMSE is calculated for the whole stack. If 'segmented', the RMSE is calculated for the sos, pos and eos segments. - :returns: computed xarray.DataArray with the RMSE - """ - # shape = ans.copy(); original_stack=ndvi.copy(); LSP_stack = ans2.copy() - computed_stack = self._obj # inShape, phen || # original_stack = inData = dstack - - # 1. Check if I'm PhenoShape data - if 'computePheno' not in self.kwargs: - raise('It seems computePheno has not yet been computed...') - - if nan_replace is not None: - original_stack = original_stack.where(original_stack.values != nan_replace) - - # 2. Get day of the year of original_stack and reorder by that - doys = original_stack.time.dt.dayofyear.values - sdoys = sorted(doys) - original_stack = original_stack.assign_coords(time=doys) - if 'doy' in original_stack.coords or 'doy' in original_stack.dims: - pass - else: - original_stack = original_stack.rename({'time': 'doy'}) - - original_stack = original_stack.sortby('doy') - - # 3. Linear interpolation for pheno, to match original_stack doys - if interpolate_nans: - computed_stack = computed_stack.interpolate_na('doy') - - computed_stack = computed_stack.interp(doy=sdoys, method='linear') - - # If the dimension 'time' exists and 'doy' doesn't, rename 'time' to 'doy' - if 'time' in original_stack.dims and 'doy' not in original_stack.dims: - if 'doy' in original_stack.coords: - original_stack = original_stack.drop_vars('doy') - original_stack = original_stack.rename({'time': 'doy'}) - - # if 'time' in computed_stack.dims and 'doy' not in computed_stack.dims: - # if 'doy' in computed_stack.coords: - # computed_stack = computed_stack.drop_vars('doy') - # computed_stack = computed_stack.rename({'time': 'doy'}) - - # Ensure the dimension names are now consistent between original_stack and computed_stack - # assert set(original_stack.dims) == set(ds2.dims), "Dimension names don't match between the two datasets." - - # 4. RMSE - # overall rmse - rmse = _rmse(computed_stack, original_stack, normalized) - - if segment is False: - out = {'rmse': rmse} - return xr.Dataset(out) - - elif segment is True: - # segmented rmse - sos = LSP_stack['sos'] # .expand_dims({'doy': sdoys}) - pos = LSP_stack['pos'] - eos = LSP_stack['eos'] - - x_ = len(original_stack.coords['x']) - y_ = len(original_stack.coords['y']) - temp_ = xr.DataArray(data = np.repeat(sdoys, x_*y_).reshape(len(sdoys), y_, x_), - dims = original_stack.dims, - coords = original_stack.coords, - attrs = original_stack.attrs).chunk(computed_stack.chunks) - - sosm = computed_stack.where(temp_ >= sos) - eosm = computed_stack.where(temp_ <= eos) - posm = computed_stack.where((temp_ > sos) & (temp_ < eos)) - - rmse_sos = _rmse(sosm, original_stack, normalized) - rmse_pos = _rmse(posm, original_stack, normalized) - rmse_eos = _rmse(eosm, original_stack, normalized) - - # TODO: take into account the option of a persist option (to persist here). - out = {'rmse': rmse, - 'rmse_sos': rmse_sos, - 'rmse_pos': rmse_pos, - 'rmse_eos': rmse_eos} - return xr.Dataset(out) - else: - raise ValueError("segment should be either True or False") - - def get_timeseries_metrics(self, window_length=3, metric="all", interpolType='linear', - rollWindow=5, nGS=52, RMSEnormalized=True, nan_replace=None, - interpolate_nans=False): - """ - Calculate and return a specified phenological metric timeseries. - - Parameters: - - ds (xarray.Dataset): - Input dataset containing the data to process. - - years_list (list): - List of years to consider for timeseries extraction. - - rollWindow (int): - Rolling window size used in the PhenoShape calculation. - - metric (str, list): - The specific metric to return. Choices are 'sos', 'pos', 'eos', 'los', 'msp', 'mau', 'vmsp', - 'vmau', 'aos', 'ios', 'rog', 'ros', 'rmse' [only overall rmse], 'curvature', or 'all'. Default is 'all'. - - nGS: Integer - Number of observations to predict the PhenoShape - default is 46; one per week - - interpolate_nans: boolean - should NaNs values be interpolated? - - Returns: - - xarray.DataArray: A timeseries of the specified metric. - - list of xarray.DataArray: A list of timeseries for each metric. - - Usage: - - To get the SOS timeseries: get_timeseries(ds, window_length=3, rollWindow=5, metric="sos") - - To get the RMSE timeseries: get_timeseries(ds, window_length=3, rollWindow=5, metric=["eos", "rmse"]) - """ - - metrics_dict = { - "sos": [], - "pos": [], - "eos": [], - "vsos": [], - "vpos": [], - "veos": [], - "los": [], - "msp": [], - "mau": [], - "vmsp": [], - "vmau": [], - "ampl": [], - "ios": [], - "rog": [], - "ros": [], - "sw": [], - #"rmse": [], - "curvature": [] - } - - ds = self._obj - - if 'rmse' in metric or 'all' in metric: - metrics_dict["rmse"] = [] - - # get a list of years from the dataset - if window_length <= 0: - raise ValueError("Window length should be a positive integer.") - years = np.unique(ds.year.values) - years_list = [tuple(years[i:i+window_length]) for i in range(len(years) - window_length + 1)] - - # loop through the list of years and calculate the phenoshape, LSP, RMSE, and Curvature for each timeWindow - for i in range(len(years_list)): - sample = ds.where(ds.year.isin(years_list[i]), drop=True) - year_sample = sample.year.values - mean_year = np.mean(year_sample).astype(int) - phenoshape = sample.pheno.PhenoShape(interpolType=interpolType, nan_replace=nan_replace, rollWindow=rollWindow, nGS=nGS) - lsp = phenoshape.pheno.PhenoLSP(nGS=nGS) - lsp = lsp.assign_coords(year=mean_year) - #rmse_val = phenoshape.pheno.RMSE(ds, LSP_stack=lsp, normalized=RMSEnormalized, nan_replace=nan_replace, interpolate_nans=interpolate_nans) - #rmse_val = rmse_val.assign_coords(year=mean_year) - # Only estimate rmse if it's provided in the metric list - if 'rmse' in metric or 'all' in metric: - try: - rmse_val = phenoshape.pheno.RMSE(ds, LSP_stack=lsp, normalized=RMSEnormalized, nan_replace=nan_replace, interpolate_nans=interpolate_nans, ) - rmse_val = rmse_val.assign_coords(year=mean_year) - metrics_dict["rmse"].append(rmse_val.rmse) - except: - print("Failed to compute RMSE for year:", mean_year) - rmse_val = None # Set to None or some other placeholder value - curvature_val = get_curvature(phenoshape) - curvature_val = curvature_val.assign_coords(year=mean_year) - - # append each metric to the corresponding list in the dictionary - metrics_dict["sos"].append(lsp.sos) - metrics_dict["pos"].append(lsp.pos) - metrics_dict["eos"].append(lsp.eos) - metrics_dict["vsos"].append(lsp.vsos) - metrics_dict["vpos"].append(lsp.vpos) - metrics_dict["veos"].append(lsp.veos) - metrics_dict["los"].append(lsp.los) - metrics_dict["msp"].append(lsp.msp) - metrics_dict["mau"].append(lsp.mau) - metrics_dict["vmsp"].append(lsp.vmsp) - metrics_dict["vmau"].append(lsp.vmau) - metrics_dict["ampl"].append(lsp.ampl) - metrics_dict["ios"].append(lsp.ios) - metrics_dict["rog"].append(lsp.rog) - metrics_dict["ros"].append(lsp.ros) - metrics_dict["sw"].append(lsp.sw) - metrics_dict["curvature"].append(curvature_val) - - # concatenate the lists of each metric into a single xarray DataArray - for key in metrics_dict: - metrics_dict[key] = xr.concat(metrics_dict[key], dim='time') - - if metric == 'all': - metric = list(metrics_dict.keys()) - - # if a single metric string is provided, convert it to a list - elif isinstance(metric, str): - metric = [metric] - - # Return the timeseries for the specified metric(s) - return {m: metrics_dict[m] for m in metric} - - - diff --git a/phenopy/utils.py b/phenopy/utils.py deleted file mode 100644 index 9e065ae..0000000 --- a/phenopy/utils.py +++ /dev/null @@ -1,363 +0,0 @@ -import sys -import numpy as np -import warnings -# from kneed import KneeLocator # (for phenotype == 2, deprecated -from scipy.integrate import trapz -from scipy.interpolate import Rbf, interp1d -from scipy.stats import skew -from sklearn.metrics import mean_squared_error -import xarray as xr - - -def reorder_southern_hemisphere(img: xr.Dataset): - """ - Reorder the DOY of the img for the Southern Hemisphere to ensure - peak summer is in the middle. This reordering is critical for some applications - like phenological studies. - - :param img: xarray Dataset with `time` and `doy` dimensions/coordinates. - :return: The input xarray Dataset reordered by DOY. - """ - doy = img.doy.values - time_values = img.time.values - - arr1 = np.linspace(183, 365, int(365-180)).astype(int) - arr2 = np.linspace(1, 185, 180).astype(int) - result = np.concatenate((arr1, arr2)) - positions = [np.where(result == value)[0][0] for value in doy] - - # Create a mapping of DOY value to its position in 'result' - position_map = {value: np.where(result == value)[0][0] for value in doy} - - # Reorder the time values based on the mapping - reordered_times = sorted(time_values, key=lambda x: position_map[img.sel(time=x).doy.values.item()]) - - # Re-index the img using the reordered time values - da = img.sel(time=reordered_times) - da.doy.values = np.linspace(1, 365, len(da.time.values))#np.sort(doy)# - - return positions, da - - -def _getPheno(y, x, nGS, interpolType): - """ - Apply linear interpolation in the 'time' axis - x: DOY values - y: ndarray with VI values - """ - inds = np.isnan(y) # check if array has NaN values - if np.sum(inds) == len(y): # check if all values are NaN - return y[0:nGS] - else: - try: - xnew = np.linspace(np.min(x), np.max(x), nGS, dtype=np.int32) - if inds.any(): # if inds have at least one True - y = _fillNaN(y) - _replaceElements(x) # replace doy values when they are the same - if interpolType == 'linear': - ynew = np.interp(xnew, x, y) - elif interpolType == 'RBF': - f = Rbf(x, y, function='cubic') # you had a typo here 'funciton' instead of 'function' - ynew = f(xnew) - elif interpolType == 'KDE': - ynew = _KDE(x, y, nGS) - else: - f = interp1d(x, y, kind=interpolType) - ynew = f(xnew) - return ynew # Moved this line to be outside the if-elif-else chain - except Exception as e: # It's good to handle exceptions in the try block - print(f"An error occurred: {e}") - return None - -def _getPheno0(y, doy, interpolType, nan_replace, rollWindow, nGS): - - # replace nan_relace values by NaN - if nan_replace is not None: - y = np.where(y == nan_replace, np.nan, y) - - # sort values by DOY - idx = doy.argsort() - y = y[idx] - - # prepare tails for interpolation - ''' - minn = np.nanmin(y) - start = y[0:3] - end = y[-3:] - if np.all( np.isnan(start) ): - y[0:3] = minn - if np.all( np.isnan(end) ): - y[-3:] = minn - ''' - # get phenological shape - phen = _getPheno(y, - doy[idx], - #doy, - nGS, - interpolType) - - # rolling average using moving window - if rollWindow is not None: - phen = _moving_average(phen, rollWindow) - - return phen - -def _getLSPmetrics2(phen, xnew, nGS, bands, phentype): - """ - Obtain land surfurface phenology metrics - - Parameters - ---------- - - phen: 1D array - PhenoShape data - - xnew: 1D array - DOY values for PhenoShape data - - bands: string list - Name of the output bands (soft requirement) - - Outputs - ------- - - 2D array with the following variables: - - SOS = DOY of start of season - POS = DOY of peak of season - EOS = DOY of end of season - vSOS = Value at start of season - vPOS = Value at peak of season - vEOS = Value at end of season - LOS = Length of season (DOY) - MSP = Mean spring (DOY) - MAU = Mean autum (DOY) - vMSP = Mean spring value - vMAU = Mean autum value - AOS = Amplitude of season (in value units) - IOS = Integral of season (SOS-EOS) - ROG = Rate of greening [slope SOS-POS] - ROS = Rate of senescence [slope POS-EOS] - SW = Skewness of growing season - """ - inds = np.isnan(phen) # check if array has NaN values - if inds.any(): # check is all values are NaN - return np.repeat(np.nan, len(bands)) - else: - # basic variables - vpos = np.max(phen) - trough = np.min(phen) - ampl = vpos - trough - - # get position of seasonal peak and trough - ipos = np.where(phen == vpos)[0] - pos = xnew[ipos] - - # scale annual time series to 0-1 - ratio = (phen - trough) / ampl - - # separate greening from senesence values - dev = np.gradient(ratio) # first derivative - greenup = np.zeros([ratio.shape[0]], dtype=bool) - greenup[dev > 0] = True - - # select time where SOS and EOS are located (around trs value) - # KneeLocator looks for the inflection index in the curve - if phentype in [1, 2]: # estimate SOS and EOS as median of the season - if phentype == 2: - warnings.warn("Type 2 is currently not implemented", DeprecationWarning) - i = np.median(xnew[:ipos[0]][greenup[:ipos[0]]]) - ii = np.median(xnew[ipos[0]:][~greenup[ipos[0]:]]) - sos = xnew[(np.abs(xnew - i)).argmin()] - eos = xnew[(np.abs(xnew - ii)).argmin()] - isos = np.where(xnew == int(sos))[0] - ieos = np.where(xnew == eos)[0] -# elif phentype == 2: # estimate SOS and EOS by inflection curves -# #-- consider only observation before POS for SOS -# knee1 = KneeLocator(xnew[0:ipos[0]], ratio[0:ipos[0]], S=2, -# curve='convex', direction='increasing') -# sos = knee1.knee -# isos = np.where(xnew == knee1.knee)[0] - -# #-- consider only observation after POS for EOS -# x = xnew[-(nGS - ipos[0] - 1):] -# y = ratio[-(nGS - ipos[0] - 1):] -# knee2 = KneeLocator(range(len(x)), np.flip(y), S=2, -# curve='convex', direction='increasing') -# eos = x[np.where( -# np.flip(range(len(x))) == knee2.knee)[0]][0] -# ieos = np.where(xnew == eos)[0] - else: - print('phentype must be either 1 or 2') - if sos is None: - isos = 0 - sos = xnew[isos] - if eos is None: - ieos = len(xnew) - 1 - eos = xnew[ieos] - - # los: length of season - los = eos - sos - if los < 0: - los = np.nan - - # get MSP, MAU (independent from SOS and EOS) - - # mean spring - idx = np.mean(xnew[(xnew > sos) & (xnew < pos[0])]) - idx = (np.abs(xnew - idx)).argmin() # indexing value - msp = xnew[idx] # DOY of MGS - vmsp = phen[idx] # mgs value - - # mean autum - idx = np.mean(xnew[(xnew < eos) & (xnew > pos[0])]) - idx = (np.abs(xnew - idx)).argmin() # indexing value - mau = xnew[idx] # DOY of MGS - vmau = phen[idx] # mgs value - - # doy of growing season - green = xnew[(xnew > sos) & (xnew < eos)] - id_ = [] - for i in range(len(green)): - id_.append((xnew == green[i]).nonzero()[0]) - # TODO: move id_ generation to a list comprehension -> id_ = [(xnew == green[i]).nonzero()[0] for i in range(len(green))] - - # index of growing season - id = np.array([item for sublist in id_ for item in sublist]) - - # get intergral of green season - ios = trapz(phen[id], xnew[id]) if len(id) > 0 else np.nan - - # skewness of growing season - sw = skew(phen[id]) if len(id) > 0 else np.nan - - # rate of greening [slope SOS-POS] - rog = (vpos - phen[isos]) / (pos - sos) - - # rate of senescence [slope POS-EOS] - ros = (phen[ieos] - vpos) / (eos - pos) - - metrics = np.array((sos, pos[0], eos, phen[isos][0], vpos, - phen[ieos][0], los, msp, mau, vmsp, vmau, ampl, ios, rog[0], - ros[0], sw)) - - return metrics - - -def _getPheno2D(dstack, doy, interpolType, nan_replace, rollWindow, nGS, xnew=None): - # dstack.doy - ans = np.apply_along_axis(_getPheno0, 0, dstack, doy, interpolType, nan_replace, rollWindow, nGS) - - # TODO: ¿_getPheno0 cambia el orden del arreglo? si es así, debo corregir - DONE? - # TODO: retornar día del año modificado, eliminar time/year, usar xnew (nuevo doy) - DONE! - # Esto se llama PhenoShape - - if xnew is None: - xnew = range(1, nGS + 1) - - return _assemble(ans, dstack, {'time': xnew}, True) - - -def _parseLSP(dstack, xnew, nGS, bands, phentype): - # num=len(bandNames) = 16 - ans = np.apply_along_axis(_getLSPmetrics2, 0, dstack, xnew, nGS, bands, phentype) - - return _assemble(ans, dstack, {'doy': bands}, True) - - -def _assemble(computed_data, original_stack, z_values, asDataArray=True): - coords_ = z_values - coords_['y'] = original_stack['y'] - coords_['x'] = original_stack['x'] - - if asDataArray: - out = xr.DataArray(computed_data, - coords=coords_, - dims=original_stack.dims) - else: - pass - - return out - - -def _rmse(computed_stack, original_stack, normalized=False): - # Compute RMSE - N = len(computed_stack['doy']) - squared_difference = (original_stack - computed_stack)**2 - mean_squared_error = squared_difference.sum('doy', keep_attrs=True, skipna=True) / N - rmse = mean_squared_error**0.5 - - if normalized: - minn = original_stack.min(dim='doy', skipna=True) - maxx = original_stack.max(dim='doy', skipna=True) - return rmse/(maxx-minn) - else: - return rmse - -def _KDE(x, y, nGS): - """Compute a bivariate kde using KDEpy.""" - - # Grid points in the x and y direction - grid_points_x, grid_points_y = nGS + 6, 2**8 - - # Stack the data for 2D input, compute the KDE - data = np.vstack((x, y)).T - kde = FFTKDE(bw=0.025).fit(data) - grid, points = kde.evaluate((grid_points_x, grid_points_y)) - - # Retrieve grid values, reshape output and plot boundaries - x2, y2 = np.unique(grid[:, 0]), np.unique(grid[:, 1]) - z = points.reshape(grid_points_x, grid_points_y) - - # Compute y_pred = E[y | x] = sum_y p(y | x) * y - y_pred = np.sum((z.T / np.sum(z, axis=1)).T * y2, axis=1) - id = np.where(x2 < np.min(x)) - x2 = np.delete(x2, id) - y_pred = np.delete(y_pred, id) - id = np.where(x2 > np.max(x)) - y_pred = np.delete(y_pred, id) - - return y_pred - -def computeChunkSize(arr, sizeMB=100, Z='time'): - """ - TODO: PENDING! - :param sizeMB: aprox desired chunk size in MB. - :param Z: name of the Z axis. By default, 'time'. - """ - bmod = arr.dtype.itemsize - ds = arr.shape - if len(ds) != 3: - raise(f'DataArray dimensions should be 3, not {ds}') - total_sizeMB = reduce(lambda x, y: x*y, ds) / 1000**2 * bmod - if total_sizeMB >= sizeMB: - pass - else: - chunk = dict(zip(arr.dims, ds)) - return chunk - - -def _moving_average(a, n=3) : - out = np.convolve(a, np.ones(n), 'valid') / n - return np.concatenate([ a[:np.int32(n/2)], out, a[-np.int32(n/2):] ]) # add values of tail - -def _fillNaN(x): - # Fill NaN data by linear interpolation - mask = np.isnan(x) - x[mask] = np.interp(np.flatnonzero(mask), np.flatnonzero(~mask), x[~mask]) - return x - -def _replaceElements(arr): - ''' - Replace monotonic vector values to avoid - interpolation errors - ''' - s = [] - for i in range(len(arr)): - # check whether the element - # is repeated or not - if arr[i] not in s: - s.append(arr[i]) - else: - # find the next greatest element - for j in range(arr[i] + 1, sys.maxsize): - if j not in s: - arr[i] = j - s.append(j) - break diff --git a/phenopy/ExampleData.ipynb b/phenosensing/ExampleData.ipynb similarity index 100% rename from phenopy/ExampleData.ipynb rename to phenosensing/ExampleData.ipynb diff --git a/phenosensing/__init__.py b/phenosensing/__init__.py new file mode 100644 index 0000000..41da1d5 --- /dev/null +++ b/phenosensing/__init__.py @@ -0,0 +1,40 @@ +"""PhenoSensing — land surface phenology metrics from satellite image time series. + +Importing this package registers the ``pheno`` accessor on +``xarray.DataArray`` objects, so that ``da.pheno.PhenoShape(...)`` and the +other phenology methods become available. +""" + +# Importing the accessor module runs the ``@xr.register_dataarray_accessor`` +# decorator as a side effect, registering the ``pheno`` namespace. +from .accessor import Pheno # noqa: F401 +from .anomaly import anomaly # noqa: F401 +from .curvature import classify_vector_numeric, get_curvature # noqa: F401 +from .extraction import list_extractors # noqa: F401 +from .io import list_samples, load_sample # noqa: F401 +from .qa import list_qa_specs, qa_to_weight # noqa: F401 +from .reconstruction import list_reconstructors # noqa: F401 +from .season import n_seasons # noqa: F401 +from .trends import trend # noqa: F401 +from .uncertainty import uncertainty # noqa: F401 +from .utils import reorder_southern_hemisphere # noqa: F401 + +__version__ = "0.1.0" + +__all__ = [ + "Pheno", + "get_curvature", + "classify_vector_numeric", + "reorder_southern_hemisphere", + "load_sample", + "list_samples", + "list_reconstructors", + "list_extractors", + "trend", + "anomaly", + "n_seasons", + "uncertainty", + "qa_to_weight", + "list_qa_specs", + "__version__", +] diff --git a/phenosensing/_numba.py b/phenosensing/_numba.py new file mode 100644 index 0000000..e366501 --- /dev/null +++ b/phenosensing/_numba.py @@ -0,0 +1,79 @@ +"""Optional Numba-accelerated kernels (the ``[fast]`` extra). + +These provide a GIL-releasing, parallel fast path for the common *linear* +reconstruction. PhenoShape uses them automatically when Numba is installed and +the inputs are provably equivalent to the pure-Python path (linear method, +in-memory array, no NaNs, no custom params); otherwise it falls back to the +pure-Python implementation, so results are identical either way. +""" + +from __future__ import annotations + +import numpy as np + +try: + from numba import njit, prange + + NUMBA_AVAILABLE = True +except ImportError: # pragma: no cover - exercised only without the [fast] extra + NUMBA_AVAILABLE = False + prange = range + + def njit(*args, **kwargs): + # Support both @njit and @njit(...) when numba is absent. + if len(args) == 1 and callable(args[0]) and not kwargs: + return args[0] + + def deco(func): + return func + + return deco + + +@njit(cache=True) +def _mov_avg(a, n): + """Moving average matching utils._moving_average for odd ``n``.""" + m = a.shape[0] + half = n // 2 + valid_len = m - n + 1 + out = np.empty(m, dtype=np.float64) + for k in range(half): + out[k] = a[k] + for k in range(valid_len): + s = 0.0 + for w in range(n): + s += a[k + w] + out[half + k] = s / n + for k in range(half): + out[half + valid_len + k] = a[m - half + k] + return out + + +@njit(parallel=True, cache=True) +def linear_phenoshape(arr, idx, doy, xnew, roll_window): + """Parallel linear reconstruction of a ``(time, y, x)`` cube. + + Mirrors the pure-Python linear path (reorder by the precomputed DOY sort + ``idx``, ``np.interp`` onto ``xnew``, optional moving average) but loops + over pixels in compiled, GIL-released code. ``idx`` is computed by NumPy + so the tie-ordering of duplicate DOYs matches the pure-Python path exactly. + """ + T = arr.shape[0] + Y = arr.shape[1] + X = arr.shape[2] + nGS = xnew.shape[0] + doy_s = np.empty(T, dtype=np.float64) + for t in range(T): + doy_s[t] = doy[idx[t]] + out = np.empty((nGS, Y, X), dtype=np.float64) + for j in prange(Y): + for k in range(X): + y_s = np.empty(T, dtype=np.float64) + for t in range(T): + y_s[t] = arr[idx[t], j, k] + interp = np.interp(xnew, doy_s, y_s) + if roll_window >= 2: + interp = _mov_avg(interp, roll_window) + for g in range(nGS): + out[g, j, k] = interp[g] + return out diff --git a/phenosensing/accessor.py b/phenosensing/accessor.py new file mode 100644 index 0000000..bff16a1 --- /dev/null +++ b/phenosensing/accessor.py @@ -0,0 +1,446 @@ +############################################################################### +# +# PhenoSensing is a Python 3.X library to process phenology indices derived from +# EarthObservation data. +# +############################################################################### + +from __future__ import annotations + +# standard library +import warnings + +# common dependencies +import numpy as np +import xarray as xr # manipulate 3D time-series rasters + +from . import _numba +from .curvature import get_curvature + +# functions from sibling modules +from .utils import LSP_BANDS, _getLSPmetrics2, _getPheno0, _getPheno0_weighted, _rmse + + +@xr.register_dataarray_accessor("pheno") +class Pheno: + def __init__(self, xr_obj: xr.DataArray) -> None: + self._obj = xr_obj + self.kwargs = {} + self.LSP_bands = list(LSP_BANDS) + + def PhenoShape( + self, + interpolType: str = "linear", + nan_replace: float | None = None, + rollWindow: int = 5, + nGS: int = 52, + recon_params: dict | None = None, + chunks: dict | None = None, + weights: xr.DataArray | None = None, + ) -> xr.DataArray: + """ + Reconstruct a smoothed phenological shape per pixel. + + Maps the chosen reconstruction method along the time axis with + ``xarray.apply_ufunc`` (Dask-parallelised when the input is chunked). + + :param interpolType: reconstruction method (see ``phenosensing.reconstruction``). + :param nan_replace: value to treat as NaN before reconstruction. + :param rollWindow: moving-average window applied to the reconstructed curve. + :param nGS: number of output points per cycle (default 52, ~weekly). + :param recon_params: optional dict of method-specific parameters. + :param chunks: optional spatial chunking (e.g. ``{"x": 300, "y": 300}``) for + out-of-core / parallel processing; the time axis is kept whole. + :param weights: optional per-observation weights ``(time, y, x)`` in [0, 1], + e.g. from :func:`phenosensing.qa.qa_to_weight`. Forwarded to reconstructors + that support them (notably ``"whittaker"``); ``None`` keeps the + unweighted behaviour unchanged. + :returns: an xarray.DataArray with a ``doy`` dimension of length ``nGS``. + """ + stack = self._obj + doy = stack.doy.values + xnew = np.linspace(np.min(doy), np.max(doy), nGS, dtype=np.int32) + + # Fast path: Numba-parallel linear reconstruction for in-memory rasters. + # Only used where it provably matches the pure-Python path. + if ( + _numba.NUMBA_AVAILABLE + and interpolType == "linear" + and recon_params is None + and nan_replace is None + and chunks is None + and weights is None + and stack.chunks is None + and (rollWindow is None or (isinstance(rollWindow, int) and rollWindow % 2 == 1)) + ): + arr = np.asarray(stack.transpose("time", "y", "x").values, dtype=np.float64) + if not np.isnan(arr).any(): + idx = np.argsort(np.asarray(doy)).astype(np.int64) + out = _numba.linear_phenoshape( + arr, + idx, + np.asarray(doy, dtype=np.float64), + np.asarray(xnew, dtype=np.float64), + int(rollWindow or 0), + ) + return xr.DataArray( + out, + dims=("doy", "y", "x"), + coords={"doy": xnew, "y": stack.coords["y"], "x": stack.coords["x"]}, + ) + + # drop the time-associated coords so the new 'doy' output dim can't + # clash with the input 'doy' coordinate + stack = stack.drop_vars(["doy", "year"], errors="ignore") + if chunks is not None: + stack = stack.chunk(chunks) + if stack.chunks is not None: + # apply_ufunc consumes the whole time axis per pixel + stack = stack.chunk({"time": -1}) + + kwargs = { + "doy": doy, + "interpolType": interpolType, + "nan_replace": nan_replace, + "rollWindow": rollWindow, + "nGS": nGS, + "recon_params": recon_params, + } + gufunc_kwargs = { + "output_core_dims": [["doy"]], + "exclude_dims": {"time"}, + "vectorize": True, + "dask": "parallelized", + "dask_gufunc_kwargs": {"output_sizes": {"doy": nGS}}, + "output_dtypes": [float], + } + + if weights is None: + stackP = xr.apply_ufunc( + _getPheno0, stack, input_core_dims=[["time"]], kwargs=kwargs, **gufunc_kwargs + ) + else: + # weighted path: map QA weights along time as a second input array + w = weights.drop_vars(["doy", "year"], errors="ignore") + if stack.chunks is not None: + w = w.chunk({"time": -1}) + stackP = xr.apply_ufunc( + _getPheno0_weighted, + stack, + w, + input_core_dims=[["time"], ["time"]], + kwargs=kwargs, + **gufunc_kwargs, + ) + return stackP.assign_coords(doy=xnew).transpose("doy", ...) + + def PhenoLSP( + self, + nGS: int | None = None, + phentype: int = 1, + extraction: str | None = None, + extract_params: dict | None = None, + ) -> xr.Dataset: + """ + Obtain land surface phenology metrics for a PhenoShape product + + Parameters + ---------- + - inData: String + Absolute path to PhenoShape raster data + - outData: String + Absolute path for output land surface phenology raster + - doy: 1D array + Numpy array of the days of the year of the time series + - nGS: Integer + Number of observations to predict the PhenoShape + default is 46; one per week + - phenType: Type os estimation of SOS and EOS. 1 = median value between POS and start and end of season. 2 = using the knee inflexion method. default 1 + + """ + stack = self._obj + if "doy" not in stack.dims: + raise ValueError( + "PhenoLSP expects a PhenoShape output (a 'doy' dimension). Run PhenoShape() first." + ) + + xnew = stack["doy"].values + if nGS is None: + nGS = len(xnew) + n_ = len(self.LSP_bands) + + if stack.chunks is not None: + stack = stack.chunk({"doy": -1}) + + stackP = xr.apply_ufunc( + _getLSPmetrics2, + stack, + input_core_dims=[["doy"]], + output_core_dims=[["LSP_bands"]], + exclude_dims={"doy"}, + vectorize=True, + dask="parallelized", + dask_gufunc_kwargs={"output_sizes": {"LSP_bands": n_}}, + output_dtypes=[float], + kwargs={ + "xnew": xnew, + "nGS": nGS, + "bands": self.LSP_bands, + "phentype": phentype, + "extraction": extraction, + "extract_params": extract_params, + }, + ) + return stackP.assign_coords(LSP_bands=self.LSP_bands).to_dataset("LSP_bands") + + def RMSE( + self, + original_stack: xr.DataArray, + LSP_stack: xr.Dataset, + normalized: bool = False, + nan_replace: float | None = None, + interpolate_nans: bool = False, + segment: bool = False, + ) -> xr.Dataset: + """ + Calculate the RMSE of the PhenoShape estimation; it can also do it by section, using the sos, pos and eos from the LSP computation (if provided). + + :param original_stack: initial image stack, from which the phenoShape was calculated. + :param LSP_stack: LSP computed stack. + :param normalized: boolean, if True RMSE will be scaled to [0, 1]. + :param nan_replace: values to be converted to NaN. + :param interpolate_nans: boolean, should NaNs values be interpolated? + :param metrics: string, either 'overall' or 'segmented'. If 'overall', the RMSE is calculated for the whole stack. If 'segmented', the RMSE is calculated for the sos, pos and eos segments. + :returns: computed xarray.DataArray with the RMSE + """ + # shape = ans.copy(); original_stack=ndvi.copy(); LSP_stack = ans2.copy() + computed_stack = self._obj # inShape, phen || # original_stack = inData = dstack + + # 1. Check this is PhenoShape output (it must carry a 'doy' dimension) + if "doy" not in computed_stack.dims: + raise ValueError( + "RMSE expects a PhenoShape output (a 'doy' dimension). Run PhenoShape() first." + ) + + if nan_replace is not None: + original_stack = original_stack.where(original_stack.values != nan_replace) + + # 2. Get day of the year of original_stack and reorder by that + doys = original_stack.time.dt.dayofyear.values + sdoys = sorted(doys) + original_stack = original_stack.assign_coords(time=doys) + if "doy" in original_stack.coords or "doy" in original_stack.dims: + pass + else: + original_stack = original_stack.rename({"time": "doy"}) + + original_stack = original_stack.sortby("doy") + + # 3. Linear interpolation for pheno, to match original_stack doys + if interpolate_nans: + computed_stack = computed_stack.interpolate_na("doy") + + computed_stack = computed_stack.interp(doy=sdoys, method="linear") + + # If the dimension 'time' exists and 'doy' doesn't, rename 'time' to 'doy' + if "time" in original_stack.dims and "doy" not in original_stack.dims: + if "doy" in original_stack.coords: + original_stack = original_stack.drop_vars("doy") + original_stack = original_stack.rename({"time": "doy"}) + + # if 'time' in computed_stack.dims and 'doy' not in computed_stack.dims: + # if 'doy' in computed_stack.coords: + # computed_stack = computed_stack.drop_vars('doy') + # computed_stack = computed_stack.rename({'time': 'doy'}) + + # Ensure the dimension names are now consistent between original_stack and computed_stack + # assert set(original_stack.dims) == set(ds2.dims), "Dimension names don't match between the two datasets." + + # 4. RMSE + # overall rmse + rmse = _rmse(computed_stack, original_stack, normalized) + + if segment is False: + out = {"rmse": rmse} + return xr.Dataset(out) + + elif segment is True: + # segmented rmse + sos = LSP_stack["sos"] # .expand_dims({'doy': sdoys}) + eos = LSP_stack["eos"] + + x_ = len(original_stack.coords["x"]) + y_ = len(original_stack.coords["y"]) + temp_ = xr.DataArray( + data=np.repeat(sdoys, x_ * y_).reshape(len(sdoys), y_, x_), + dims=original_stack.dims, + coords=original_stack.coords, + attrs=original_stack.attrs, + ) + # match the input's chunking only when it is actually dask-backed + # (``.chunk(None)`` is deprecated) + if computed_stack.chunks is not None: + temp_ = temp_.chunk(computed_stack.chunksizes) + + sosm = computed_stack.where(temp_ >= sos) + eosm = computed_stack.where(temp_ <= eos) + posm = computed_stack.where((temp_ > sos) & (temp_ < eos)) + + rmse_sos = _rmse(sosm, original_stack, normalized) + rmse_pos = _rmse(posm, original_stack, normalized) + rmse_eos = _rmse(eosm, original_stack, normalized) + + # TODO: take into account the option of a persist option (to persist here). + out = {"rmse": rmse, "rmse_sos": rmse_sos, "rmse_pos": rmse_pos, "rmse_eos": rmse_eos} + return xr.Dataset(out) + else: + raise ValueError("segment should be either True or False") + + def get_timeseries_metrics( + self, + window_length: int = 3, + metric: str | list[str] = "all", + interpolType: str = "linear", + rollWindow: int = 5, + nGS: int = 52, + RMSEnormalized: bool = True, + nan_replace: float | None = None, + interpolate_nans: bool = False, + recon_params: dict | None = None, + extraction: str | None = None, + extract_params: dict | None = None, + ) -> dict: + """ + Calculate and return a specified phenological metric timeseries. + + Parameters: + - ds (xarray.Dataset): + Input dataset containing the data to process. + - years_list (list): + List of years to consider for timeseries extraction. + - rollWindow (int): + Rolling window size used in the PhenoShape calculation. + - metric (str, list): + The specific metric to return. Choices are 'sos', 'pos', 'eos', 'los', 'msp', 'mau', 'vmsp', + 'vmau', 'aos', 'ios', 'rog', 'ros', 'rmse' [only overall rmse], 'curvature', or 'all'. Default is 'all'. + - nGS: Integer + Number of observations to predict the PhenoShape + default is 46; one per week + - interpolate_nans: boolean + should NaNs values be interpolated? + + Returns: + - xarray.DataArray: A timeseries of the specified metric. + - list of xarray.DataArray: A list of timeseries for each metric. + + Usage: + - To get the SOS timeseries: get_timeseries(ds, window_length=3, rollWindow=5, metric="sos") + - To get the RMSE timeseries: get_timeseries(ds, window_length=3, rollWindow=5, metric=["eos", "rmse"]) + """ + + metrics_dict = { + "sos": [], + "pos": [], + "eos": [], + "vsos": [], + "vpos": [], + "veos": [], + "los": [], + "msp": [], + "mau": [], + "vmsp": [], + "vmau": [], + "ampl": [], + "ios": [], + "rog": [], + "ros": [], + "sw": [], + "trough": [], + "mos": [], + # "rmse": [], + "curvature": [], + } + + ds = self._obj + + if "rmse" in metric or "all" in metric: + metrics_dict["rmse"] = [] + + # get a list of years from the dataset + if window_length <= 0: + raise ValueError("Window length should be a positive integer.") + years = np.unique(ds.year.values) + years_list = [ + tuple(years[i : i + window_length]) for i in range(len(years) - window_length + 1) + ] + + # loop through the list of years and calculate the phenoshape, LSP, RMSE, and Curvature for each timeWindow + for i in range(len(years_list)): + sample = ds.where(ds.year.isin(years_list[i]), drop=True) + year_sample = sample.year.values + mean_year = np.mean(year_sample).astype(int) + phenoshape = sample.pheno.PhenoShape( + interpolType=interpolType, + nan_replace=nan_replace, + rollWindow=rollWindow, + nGS=nGS, + recon_params=recon_params, + ) + lsp = phenoshape.pheno.PhenoLSP( + nGS=nGS, extraction=extraction, extract_params=extract_params + ) + lsp = lsp.assign_coords(year=mean_year) + # rmse_val = phenoshape.pheno.RMSE(ds, LSP_stack=lsp, normalized=RMSEnormalized, nan_replace=nan_replace, interpolate_nans=interpolate_nans) + # rmse_val = rmse_val.assign_coords(year=mean_year) + # Only estimate rmse if it's provided in the metric list + if "rmse" in metric or "all" in metric: + try: + rmse_val = phenoshape.pheno.RMSE( + ds, + LSP_stack=lsp, + normalized=RMSEnormalized, + nan_replace=nan_replace, + interpolate_nans=interpolate_nans, + ) + rmse_val = rmse_val.assign_coords(year=mean_year) + metrics_dict["rmse"].append(rmse_val.rmse) + except Exception as e: + warnings.warn(f"Failed to compute RMSE for year {mean_year}: {e}") + rmse_val = None # placeholder + curvature_val = get_curvature(phenoshape) + curvature_val = curvature_val.assign_coords(year=mean_year) + + # append each metric to the corresponding list in the dictionary + metrics_dict["sos"].append(lsp.sos) + metrics_dict["pos"].append(lsp.pos) + metrics_dict["eos"].append(lsp.eos) + metrics_dict["vsos"].append(lsp.vsos) + metrics_dict["vpos"].append(lsp.vpos) + metrics_dict["veos"].append(lsp.veos) + metrics_dict["los"].append(lsp.los) + metrics_dict["msp"].append(lsp.msp) + metrics_dict["mau"].append(lsp.mau) + metrics_dict["vmsp"].append(lsp.vmsp) + metrics_dict["vmau"].append(lsp.vmau) + metrics_dict["ampl"].append(lsp.ampl) + metrics_dict["ios"].append(lsp.ios) + metrics_dict["rog"].append(lsp.rog) + metrics_dict["ros"].append(lsp.ros) + metrics_dict["sw"].append(lsp.sw) + metrics_dict["trough"].append(lsp.trough) + metrics_dict["mos"].append(lsp.mos) + metrics_dict["curvature"].append(curvature_val) + + # concatenate the lists of each metric into a single xarray DataArray + for key in metrics_dict: + metrics_dict[key] = xr.concat(metrics_dict[key], dim="time") + + if metric == "all": + metric = list(metrics_dict.keys()) + + # if a single metric string is provided, convert it to a list + elif isinstance(metric, str): + metric = [metric] + + # Return the timeseries for the specified metric(s) + return {m: metrics_dict[m] for m in metric} diff --git a/phenosensing/anomaly.py b/phenosensing/anomaly.py new file mode 100644 index 0000000..ec9d702 --- /dev/null +++ b/phenosensing/anomaly.py @@ -0,0 +1,88 @@ +"""Non-parametric phenological anomaly detection (npphen-style). + +For each pixel this compares the observed vegetation index against the +climatological phenological cycle (the :meth:`PhenoShape`) and expresses how +anomalous each observation is: + +- ``anomaly`` -- the raw deviation (observed - expected); +- ``z`` -- the anomaly standardised by the per-pixel anomaly spread; +- ``rfd`` -- a Reference Frequency Distribution percentile in (0, 1]: where the + anomaly falls within the pixel's historical anomaly distribution. Values near + 0 are extreme negative anomalies (e.g. drought / dieback), near 1 extreme + positive (e.g. unusual greening), near 0.5 typical. + +Reference: Estay & Chavez, ``npphen`` (non-parametric vegetation phenology and +anomaly detection). +""" + +from __future__ import annotations + +import numpy as np +import xarray as xr +from scipy.stats import rankdata + + +def _rfd_1d(a): + """Empirical percentile (RFD) of each value among the finite values of ``a``.""" + out = np.full(a.shape, np.nan) + mask = np.isfinite(a) + n = int(mask.sum()) + if n < 2: + return out + out[mask] = rankdata(a[mask]) / n + return out + + +def anomaly( + da: xr.DataArray, + reference: xr.DataArray | None = None, + interpolType: str = "linear", + nGS: int = 52, + rollWindow: int = 5, + standardize: bool = True, +) -> xr.Dataset: + """Phenological anomalies of ``da`` against a climatological reference. + + Parameters + ---------- + da: + ``(time, y, x)`` vegetation-index cube with a ``doy`` coordinate. + reference: + Cube used to build the climatology (default: ``da`` itself). Pass a + held-out reference period to assess a target period against it. + interpolType: + Reconstruction method for the climatology. ``"KDE"`` gives a fully + non-parametric, npphen-style reference (needs the ``[kde]`` extra). + nGS, rollWindow: + Passed through to ``PhenoShape`` when building the climatology. + standardize: + Also return a z-score (anomaly divided by the per-pixel anomaly std). + + Returns + ------- + xarray.Dataset + ``anomaly`` (observed - expected), ``rfd`` (empirical percentile in + (0, 1]) and, when ``standardize``, ``z`` -- all with dims + ``(time, y, x)``. + """ + ref = da if reference is None else reference + shape = ref.pheno.PhenoShape(interpolType=interpolType, nGS=nGS, rollWindow=rollWindow) + + # expected vegetation index at each observation's day-of-year + expected = shape.interp(doy=da["doy"]) + anomaly_da = (da - expected).rename("anomaly") + + rfd = xr.apply_ufunc( + _rfd_1d, + anomaly_da, + input_core_dims=[["time"]], + output_core_dims=[["time"]], + vectorize=True, + dask="parallelized", + output_dtypes=[float], + ).rename("rfd") + + data = {"anomaly": anomaly_da, "rfd": rfd} + if standardize: + data["z"] = (anomaly_da / anomaly_da.std("time", skipna=True)).rename("z") + return xr.Dataset(data) diff --git a/phenopy/curvature.py b/phenosensing/curvature.py similarity index 70% rename from phenopy/curvature.py rename to phenosensing/curvature.py index 2b45d1f..1bc6768 100644 --- a/phenopy/curvature.py +++ b/phenosensing/curvature.py @@ -1,10 +1,11 @@ import numpy as np import xarray as xr + def classify_vector_numeric(v: np.ndarray) -> float: """ Calculate and return the sum of the second difference of a vector. - + Parameters: - v : numpy ndarray Input vector. @@ -15,10 +16,11 @@ def classify_vector_numeric(v: np.ndarray) -> float: """ return np.sum(np.diff(v, n=2)) + def get_curvature(phenoshape: xr.DataArray) -> xr.DataArray: """ Calculate the curvature for each point in a phenoshape xarray. - + Parameters: - phenoshape : xarray DataArray Input data array which should have 'doy' as a coordinate or a dimension. @@ -28,20 +30,22 @@ def get_curvature(phenoshape: xr.DataArray) -> xr.DataArray: Curvature values. """ # Check if 'doy' is a dimension - if 'doy' not in phenoshape.dims: - if 'doy' in phenoshape.coords and 'time' in phenoshape.dims: + if "doy" not in phenoshape.dims: + if "doy" in phenoshape.coords and "time" in phenoshape.dims: # Temporarily swap 'time' dimension with 'doy' coordinate for the operation - phenoshape = phenoshape.swap_dims({'time': 'doy'}) + phenoshape = phenoshape.swap_dims({"time": "doy"}) else: - raise ValueError("The provided xarray DataArray must have 'doy' as a coordinate or a dimension.") - + raise ValueError( + "The provided xarray DataArray must have 'doy' as a coordinate or a dimension." + ) + curvature = xr.apply_ufunc( classify_vector_numeric, phenoshape, - input_core_dims=[['doy']], + input_core_dims=[["doy"]], vectorize=True, dask="parallelized", - output_dtypes=[phenoshape.dtype] + output_dtypes=[phenoshape.dtype], ) - return curvature \ No newline at end of file + return curvature diff --git a/phenopy/data/Fig_Segmented_nRMSE.jpg b/phenosensing/data/Fig_Segmented_nRMSE.jpg similarity index 100% rename from phenopy/data/Fig_Segmented_nRMSE.jpg rename to phenosensing/data/Fig_Segmented_nRMSE.jpg diff --git a/phenopy/data/SIF_sample.tif b/phenosensing/data/SIF_sample.tif similarity index 100% rename from phenopy/data/SIF_sample.tif rename to phenosensing/data/SIF_sample.tif diff --git a/phenopy/data/SIF_sample_dates.csv b/phenosensing/data/SIF_sample_dates.csv similarity index 100% rename from phenopy/data/SIF_sample_dates.csv rename to phenosensing/data/SIF_sample_dates.csv diff --git a/phenopy/data/dates.txt b/phenosensing/data/dates.txt similarity index 100% rename from phenopy/data/dates.txt rename to phenosensing/data/dates.txt diff --git a/phenopy/data/dates_ndvi.csv b/phenosensing/data/dates_ndvi.csv similarity index 100% rename from phenopy/data/dates_ndvi.csv rename to phenosensing/data/dates_ndvi.csv diff --git a/phenopy/data/example_phenoshape.png b/phenosensing/data/example_phenoshape.png similarity index 100% rename from phenopy/data/example_phenoshape.png rename to phenosensing/data/example_phenoshape.png diff --git a/phenopy/data/figure.svg b/phenosensing/data/figure.svg similarity index 100% rename from phenopy/data/figure.svg rename to phenosensing/data/figure.svg diff --git a/phenopy/data/figure2.svg b/phenosensing/data/figure2.svg similarity index 100% rename from phenopy/data/figure2.svg rename to phenosensing/data/figure2.svg diff --git a/phenopy/data/kndvi_186.tif b/phenosensing/data/kndvi_186.tif similarity index 100% rename from phenopy/data/kndvi_186.tif rename to phenosensing/data/kndvi_186.tif diff --git a/phenopy/data/logo.svg b/phenosensing/data/logo.svg similarity index 100% rename from phenopy/data/logo.svg rename to phenosensing/data/logo.svg diff --git a/phenopy/data/ndvi_test.tif b/phenosensing/data/ndvi_test.tif similarity index 100% rename from phenopy/data/ndvi_test.tif rename to phenosensing/data/ndvi_test.tif diff --git a/phenopy/data/output_14_1.png b/phenosensing/data/output_14_1.png similarity index 100% rename from phenopy/data/output_14_1.png rename to phenosensing/data/output_14_1.png diff --git a/phenopy/data/timeseries_allData.svg b/phenosensing/data/timeseries_allData.svg similarity index 100% rename from phenopy/data/timeseries_allData.svg rename to phenosensing/data/timeseries_allData.svg diff --git a/phenosensing/extraction.py b/phenosensing/extraction.py new file mode 100644 index 0000000..5c32fee --- /dev/null +++ b/phenosensing/extraction.py @@ -0,0 +1,88 @@ +"""SOS / EOS extraction methods -- axis 3 of the composable pipeline. + +An *extractor* locates the start and end of season on a reconstructed, +peak-normalised curve. All share the signature:: + + extract(phen, xnew, ratio, greenup, ipos, **params) -> (sos, eos, isos, ieos) + +where ``phen`` is the reconstructed curve, ``xnew`` the DOY grid, ``ratio`` the +curve scaled to [0, 1], ``greenup`` a boolean mask of positive first-derivative +samples and ``ipos`` the index/indices of the seasonal peak. ``sos``/``eos`` are +DOY values and ``isos``/``ieos`` their indices (as length-1 arrays, matching the +historical convention used by the metric calculator). + +References +---------- +- Threshold (TRS): White et al. (1997); Jonsson & Eklundh (2004). +- Derivative / inflection: Tateishi & Ebata (2004); Gu et al. (2009). +""" + +from __future__ import annotations + +import numpy as np + + +def _seasonal_median(phen, xnew, ratio, greenup, ipos, **params): + """Historical ``phentype=1``: SOS/EOS as the median DOY of the + greening / senescing phase around the peak.""" + i = np.median(xnew[: ipos[0]][greenup[: ipos[0]]]) + ii = np.median(xnew[ipos[0] :][~greenup[ipos[0] :]]) + sos = xnew[(np.abs(xnew - i)).argmin()] + eos = xnew[(np.abs(xnew - ii)).argmin()] + isos = np.where(xnew == int(sos))[0] + ieos = np.where(xnew == eos)[0] + return sos, eos, isos, ieos + + +def _trs(phen, xnew, ratio, greenup, ipos, threshold=0.5, **params): + """Relative-amplitude threshold: SOS/EOS where the scaled curve crosses + ``threshold`` (default 0.5) on the rising / falling side of the peak.""" + p = int(ipos[0]) + rise = np.where(ratio[: p + 1] >= threshold)[0] + isos = int(rise[0]) if rise.size else 0 + fall = np.where(ratio[p:] >= threshold)[0] + ieos = int(p + fall[-1]) if fall.size else len(xnew) - 1 + return xnew[isos], xnew[ieos], np.array([isos]), np.array([ieos]) + + +def _derivative(phen, xnew, ratio, greenup, ipos, **params): + """Derivative method: SOS at the maximum greening rate and EOS at the + maximum senescence rate (extrema of the first derivative).""" + dev = np.gradient(ratio) + p = int(ipos[0]) + isos = int(np.argmax(dev[: p + 1])) if p > 0 else 0 + ieos = int(p + np.argmin(dev[p:])) if p < len(xnew) - 1 else len(xnew) - 1 + return xnew[isos], xnew[ieos], np.array([isos]), np.array([ieos]) + + +def _curvature(phen, xnew, ratio, greenup, ipos, **params): + """Inflection method: SOS/EOS at the maximum curvature (extreme of the + second derivative) on each side of the peak.""" + curv = np.gradient(np.gradient(ratio)) + p = int(ipos[0]) + isos = int(np.argmax(curv[: p + 1])) if p > 0 else 0 + ieos = int(p + np.argmax(curv[p:])) if p < len(xnew) - 1 else len(xnew) - 1 + return xnew[isos], xnew[ieos], np.array([isos]), np.array([ieos]) + + +EXTRACTORS = { + "seasonal_median": _seasonal_median, + "trs": _trs, + "der": _derivative, + "curvature": _curvature, +} + + +def list_extractors() -> list: + """Return the names of the registered SOS/EOS extraction methods.""" + return sorted(EXTRACTORS) + + +def get_extractor(name: str): + """Return the extractor callable for ``name``.""" + try: + return EXTRACTORS[name] + except KeyError: + raise ValueError( + f"Unknown extraction method {name!r}; choose from {list_extractors()}." + ) from None diff --git a/phenosensing/io.py b/phenosensing/io.py new file mode 100644 index 0000000..c8e99d4 --- /dev/null +++ b/phenosensing/io.py @@ -0,0 +1,52 @@ +"""I/O helpers for PhenoSensing, including the small bundled example datasets.""" + +from importlib.resources import files + +import pandas as pd +import rioxarray +import xarray as xr + +__all__ = ["load_sample", "list_samples"] + +# name -> (raster filename, paired date CSV filename) +_SAMPLES = { + "SIF": ("SIF_sample.tif", "SIF_sample_dates.csv"), + "ndvi": ("ndvi_test.tif", "dates_ndvi.csv"), +} + + +def list_samples() -> list: + """Return the names of the bundled example datasets.""" + return sorted(_SAMPLES) + + +def load_sample(name: str = "SIF") -> xr.DataArray: + """Load a bundled example vegetation-index time series. + + Parameters + ---------- + name: + Which bundled dataset to load; one of :func:`list_samples` + (``"SIF"`` or ``"ndvi"``). + + Returns + ------- + xarray.DataArray + A ``(time, y, x)`` array with ``doy`` and ``year`` coordinates, + ready to be used through the ``.pheno`` accessor. + """ + try: + tif_name, csv_name = _SAMPLES[name] + except KeyError: + raise ValueError(f"Unknown sample {name!r}; choose from {list_samples()}.") from None + + data_dir = files("phenosensing").joinpath("data") + dates = pd.to_datetime(pd.read_csv(str(data_dir.joinpath(csv_name)), header=None).iloc[:, 0]) + + da = rioxarray.open_rasterio(str(data_dir.joinpath(tif_name))) + da = da.rename({"band": "time"}).assign_coords(time=dates.values) + da = da.assign_coords( + doy=("time", da["time"].dt.dayofyear.values), + year=("time", da["time"].dt.year.values), + ) + return da diff --git a/phenopy/plotting.py b/phenosensing/plotting.py similarity index 51% rename from phenopy/plotting.py rename to phenosensing/plotting.py index 8ed34d2..cb42621 100644 --- a/phenopy/plotting.py +++ b/phenosensing/plotting.py @@ -1,60 +1,52 @@ +import math + +import matplotlib.pyplot as plt import numpy as np import pandas as pd -import matplotlib.pyplot as plt -import xarray as xr -from scipy.integrate import trapz -from scipy.interpolate import Rbf, interp1d -from scipy.stats import skew -from sklearn.metrics import mean_squared_error -import math -import folium -from pyproj import Proj, transform -from odc.ui import image_aspect -import warnings + +# functions from sibling modules +from .utils import _getLSPmetrics2, _getPheno0 -#import all function from utils.py -from utils import _getPheno0, _getPheno2D, _parseLSP, _getLSPmetrics2, _rmse +def display_map(x, y, crs="EPSG:4326", margin=-0.5, zoom_bias=0): + """ + Given a set of x and y coordinates, this function generates an + interactive map with a bounded rectangle overlayed on Google Maps + imagery. Based on DEAfrica notebooks -def display_map(x, y, crs='EPSG:4326', margin=-0.5, zoom_bias=0): - """ - Given a set of x and y coordinates, this function generates an - interactive map with a bounded rectangle overlayed on Google Maps - imagery. Based on DEAfrica notebooks - Last modified: September 2019 - - Modified from function written by Otto Wagner available here: + + Modified from function written by Otto Wagner available here: https://github.com/ceos-seo/data_cube_utilities/tree/master/data_cube_utilities - + Parameters - ---------- + ---------- x : (float, float) - A tuple of x coordinates in (min, max) format. + A tuple of x coordinates in (min, max) format. y : (float, float) A tuple of y coordinates in (min, max) format. crs : string, optional - A string giving the EPSG CRS code of the supplied coordinates. + A string giving the EPSG CRS code of the supplied coordinates. The default is 'EPSG:4326'. margin : float - A numeric value giving the number of degrees lat-long to pad - the edges of the rectangular overlay polygon. A larger value - results more space between the edge of the plot and the sides + A numeric value giving the number of degrees lat-long to pad + the edges of the rectangular overlay polygon. A larger value + results more space between the edge of the plot and the sides of the polygon. Defaults to -0.5. zoom_bias : float or int - A numeric value allowing you to increase or decrease the zoom - level by one step. Defaults to 0; set to greater than 0 to zoom + A numeric value allowing you to increase or decrease the zoom + level by one step. Defaults to 0; set to greater than 0 to zoom in, and less than 0 to zoom out. - + Returns ------- - folium.Map : A map centered on the supplied coordinate bounds. A - rectangle is drawn on this map detailing the perimeter of the x, y - bounds. A zoom level is calculated such that the resulting - viewport is the closest it can possibly get to the centered - bounding rectangle without clipping it. + folium.Map : A map centered on the supplied coordinate bounds. A + rectangle is drawn on this map detailing the perimeter of the x, y + bounds. A zoom level is calculated such that the resulting + viewport is the closest it can possibly get to the centered + bounding rectangle without clipping it. """ - + def _degree_to_zoom_level(l1, l2, margin=0.0): """ Helper function to set zoom level for `display_map` @@ -68,20 +60,24 @@ def _degree_to_zoom_level(l1, l2, margin=0.0): zoom_level_int = 18 return zoom_level_int - # Convert each corner coordinates to lat-lon + # heavy optional plotting deps imported lazily (the [plot] extra) + import folium + from pyproj import Transformer + + # Convert each corner coordinate to lat-lon (modern pyproj>=2 API; + # always_xy keeps (lon/easting, lat/northing) order on input and output) all_x = (x[0], x[1], x[0], x[1]) all_y = (y[0], y[0], y[1], y[1]) - all_longitude, all_latitude = transform(Proj(crs), - Proj('EPSG:4326'), - all_x, all_y) + transformer = Transformer.from_crs(crs, "EPSG:4326", always_xy=True) + all_longitude, all_latitude = transformer.transform(all_x, all_y) # Calculate zoom level based on coordinates - lat_zoom_level = _degree_to_zoom_level(min(all_latitude), - max(all_latitude), - margin=margin) + zoom_bias - lon_zoom_level = _degree_to_zoom_level(min(all_longitude), - max(all_longitude), - margin=margin) + zoom_bias + lat_zoom_level = ( + _degree_to_zoom_level(min(all_latitude), max(all_latitude), margin=margin) + zoom_bias + ) + lon_zoom_level = ( + _degree_to_zoom_level(min(all_longitude), max(all_longitude), margin=margin) + zoom_bias + ) zoom_level = min(lat_zoom_level, lon_zoom_level) # Identify centre point for plotting @@ -92,20 +88,22 @@ def _degree_to_zoom_level(l1, l2, margin=0.0): location=center, zoom_start=zoom_level, tiles="http://mt1.google.com/vt/lyrs=y&z={z}&x={x}&y={y}", - attr="Google") + attr="Google", + ) # Create bounding box coordinates to overlay on map - line_segments = [(all_latitude[0], all_longitude[0]), - (all_latitude[1], all_longitude[1]), - (all_latitude[3], all_longitude[3]), - (all_latitude[2], all_longitude[2]), - (all_latitude[0], all_longitude[0])] + line_segments = [ + (all_latitude[0], all_longitude[0]), + (all_latitude[1], all_longitude[1]), + (all_latitude[3], all_longitude[3]), + (all_latitude[2], all_longitude[2]), + (all_latitude[0], all_longitude[0]), + ] # Add bounding box as an overlay interactive_map.add_child( - folium.features.PolyLine(locations=line_segments, - color='red', - opacity=0.8)) + folium.features.PolyLine(locations=line_segments, color="red", opacity=0.8) + ) # Add clickable lat-lon popup box interactive_map.add_child(folium.features.LatLngPopup()) @@ -113,9 +111,30 @@ def _degree_to_zoom_level(l1, l2, margin=0.0): return interactive_map -def PhenoPlot(stack, X, Y, interpolType='linear', saveFigure=None, ylim=None, rollWindow=None, - nan_replace=None, correctionValue=None, plotType=1, phentype=1, nGS=52, - fontsize=14, titlesize=15, legendsize=15, labelsize=13, threshold=300, ylab='NDVI', ax=None): +def PhenoPlot( + stack, + X, + Y, + interpolType="linear", + saveFigure=None, + ylim=None, + rollWindow=None, + nan_replace=None, + correctionValue=None, + plotType=1, + phentype=1, + nGS=52, + fontsize=14, + titlesize=15, + legendsize=15, + labelsize=13, + threshold=300, + ylab="NDVI", + ax=None, + southern=False, + cmap="viridis", + many_years=8, +): """ Plot the PhenoShape curve along with the yearly data @@ -153,82 +172,126 @@ def PhenoPlot(stack, X, Y, interpolType='linear', saveFigure=None, ylim=None, ro default is 46; one per week - ylab: string Label of the Y axis [default "NDVI"] + - southern: bool + Reorder/relabel the x-axis to Southern-Hemisphere day-of-year so the + austral growing season is centred [default False] + - cmap: string + Colormap used when there are many years [default "viridis"] + - many_years: int + Above this many years, points are coloured by a continuous palette + with a colorbar instead of a per-year legend [default 8] """ - - # Get the values for the specified X and Y - doy=stack.doy.values#.where(img.year == 2017, drop=True).doy.values - dates=stack.time#.where(img.year == 2017, drop=True).time - #sorted_indices = np.argsort(doy) - # Reorder the time dimension using the sorted indices - #stack = stack.isel(time=sorted_indices) - # Get the values for the specified X and Y + + # Get the per-pixel time series + doy = stack.doy.values + dates = stack.time valuesTSS = stack.sel(x=X, y=Y, method="nearest").values - # create a DataFrame for further processing - valuesTSSpd = pd.DataFrame({ - 'dates': dates, - 'doy': dates.dt.dayofyear, - 'year': dates.dt.year, - 'VI': valuesTSS - }).sort_values('doy') - - # group values according to year - groups = valuesTSSpd.groupby('year') - # get phenological shape - phen = _getPheno0(y=valuesTSS, doy=doy, interpolType=interpolType, - nan_replace=None, rollWindow=rollWindow, nGS=nGS) - # doy of the predicted phenological shape - xnew = np.linspace(np.min(valuesTSSpd.doy), np.max(valuesTSSpd.doy), nGS, - dtype='int16') - - # Check if ax is provided, if not create one + valuesTSSpd = pd.DataFrame( + {"doy": dates.dt.dayofyear, "year": dates.dt.year, "VI": valuesTSS} + ).sort_values("doy") + + # Southern Hemisphere: map calendar DOY -> day-of-season (austral year ~1 July) + if southern: + cd = valuesTSSpd["doy"].values + plot_doy = np.where(cd >= 183, cd - 183, cd + 182) + fit_doy = np.where(doy >= 183, doy - 183, doy + 182) + xlabel = "Day of season (Southern Hemisphere)" + else: + plot_doy = valuesTSSpd["doy"].values + fit_doy = doy + xlabel = "Day of the year" + valuesTSSpd["pdoy"] = plot_doy + + phen = _getPheno0( + y=valuesTSS, + doy=fit_doy, + interpolType=interpolType, + nan_replace=nan_replace, + rollWindow=rollWindow, + nGS=nGS, + ) + xnew = np.linspace(np.min(plot_doy), np.max(plot_doy), nGS, dtype="int16") + if ax is None: - fig, ax = plt.subplots() + _, ax = plt.subplots() - # plot if plotType == 1: - for name, group in groups: - ax.plot(group.doy, group.VI, marker='o', linestyle='', ms=10, label=name) - ax.plot(xnew, phen, '-', color='black') - ax.legend(prop={'size': legendsize}) + years = sorted(valuesTSSpd["year"].unique()) + if len(years) > many_years: + # many years -> continuous palette + colorbar (instead of a large legend) + sm = plt.cm.ScalarMappable(norm=plt.Normalize(min(years), max(years)), cmap=cmap) + sm.set_array([]) + for name, group in valuesTSSpd.groupby("year"): + ax.plot(group["pdoy"], group["VI"], "o", ms=5, color=sm.to_rgba(name)) + ax.figure.colorbar(sm, ax=ax, pad=0.01).set_label("year", fontsize=fontsize) + else: + for name, group in valuesTSSpd.groupby("year"): + ax.plot(group["pdoy"], group["VI"], "o", ms=8, label=int(name)) + # legend outside the plot, on the left + ax.legend( + loc="center right", + bbox_to_anchor=(-0.12, 0.5), + fontsize=legendsize, + title="year", + frameon=False, + ) + ax.plot(xnew, phen, "-", color="black", lw=2) ax.tick_params(labelsize=labelsize) if ylim is not None: ax.set_ylim(ylim[0], ylim[1]) - ax.set_ylabel(ylab, fontsize=fontsize) - ax.set_xlabel('Day of the year', fontsize=fontsize) - + ax.set_xlabel(xlabel, fontsize=fontsize) + if southern: + _relabel_southern(ax) + elif plotType == 2: # get position of SOS, POS, and EOS metrics = _getLSPmetrics2(phen, xnew, nGS, len(xnew), phentype) isos = np.where(xnew == metrics[0])[0][0] ipos = np.where(xnew == metrics[1])[0][0] ieos = np.where(xnew == metrics[2])[0][0] - ax.plot(xnew, phen, '-', color='black') - ax.plot(xnew[isos], phen[isos], 'X', markersize=15, label='SOS') - ax.plot(xnew[ipos], phen[ipos], 'X', markersize=15, label='POS') - ax.plot(xnew[ieos], phen[ieos], 'X', markersize=15, label='EOS') - - ax.legend(prop={'size': 12}) + ax.plot(xnew, phen, "-", color="black") + ax.plot(xnew[isos], phen[isos], "X", markersize=15, label="SOS") + ax.plot(xnew[ipos], phen[ipos], "X", markersize=15, label="POS") + ax.plot(xnew[ieos], phen[ieos], "X", markersize=15, label="EOS") + ax.legend( + loc="center right", bbox_to_anchor=(-0.12, 0.5), fontsize=legendsize, frameon=False + ) ax.tick_params(labelsize=labelsize) if ylim is not None: ax.set_ylim(ylim[0], ylim[1]) ax.set_ylabel(ylab, fontsize=fontsize) - ax.set_xlabel('Day of the year', fontsize=fontsize) - - - return ax - - - -def plot_with_southern_doy(shape, coordinates, ylabel='NDVI', title=None): + ax.set_xlabel(xlabel, fontsize=fontsize) + if southern: + _relabel_southern(ax) + + if saveFigure is not None: + ax.figure.savefig(saveFigure, bbox_inches="tight") + + return ax + + +def _relabel_southern(ax): + """Relabel x-ticks (day-of-season positions) as real Southern-Hemisphere + calendar DOY (position ``p`` -> ``((p + 182) % 365) + 1``), keeping the + data-driven axis limits (``set_xticks`` would otherwise expand the view to + the locator's out-of-range ticks).""" + xlim = ax.get_xlim() + ticks = [t for t in ax.get_xticks() if xlim[0] <= t <= xlim[1]] + ax.set_xticks(ticks) + ax.set_xticklabels([int(((t + 182) % 365) + 1) for t in ticks]) + ax.set_xlim(xlim) + + +def plot_with_southern_doy(shape, coordinates, ylabel="NDVI", title=None): """ - Plot the data from a specified shape with x-ticks reordered to represent real + Plot the data from a specified shape with x-ticks reordered to represent real southern hemispherical day-of-the-year (DOY) values. - + Parameters: - - shape: xarray.DataArray + - shape: xarray.DataArray The data shape to plot. - coordinates: tuple The coordinates of the pixel to plot. @@ -236,15 +299,15 @@ def plot_with_southern_doy(shape, coordinates, ylabel='NDVI', title=None): vegetation index used in the analysis. Default is'NDVI - title: str, optional The title for the plot. Default is None, meaning no title. - + Returns: - ax: matplotlib.axes._subplots.AxesSubplot The plotted axis. """ # Plot the data with real southern hemispherical doys - X=coordinates[0] - Y=coordinates[1] + X = coordinates[0] + Y = coordinates[1] shape.sel(x=X, y=Y, method="nearest").plot() # Fetch the current active axis using Matplotlib's gca diff --git a/phenosensing/py.typed b/phenosensing/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/phenosensing/qa.py b/phenosensing/qa.py new file mode 100644 index 0000000..58485b0 --- /dev/null +++ b/phenosensing/qa.py @@ -0,0 +1,119 @@ +"""Decode a per-observation quality (QA) band into reconstruction weights. + +QA encodings are sensor-specific, but almost all reduce to one of four patterns, +each expressible as a small declarative spec (a ``dict``) -- or, for anything +exotic, a custom callable: + +- ``remap`` : map ordinal QA values to weights (e.g. MODIS ``SummaryQA``). +- ``good_classes`` : keep a set of class labels (e.g. Sentinel-2 ``SCL``). +- ``bad_bits`` : a packed bitmask (e.g. Landsat ``QA_PIXEL``). +- ``max_value`` / ``min_value`` : a continuous threshold (e.g. a cloud-probability + band). + +The decoder is deliberately **source-agnostic**: it operates on any xarray QA +``DataArray`` -- from Earth Engine, local rasters, NetCDF, ... -- so Earth Engine +is never a dependency of PhenoSensing. ``examples/`` shows a GEE -> xarray bridge that +feeds this function. Missing QA (``NaN``) is always treated as bad (weight 0). + +The resulting weights (in ``[0, 1]``) are what the weighted reconstruction +consumes; PhenoSensing's algorithms never need to know which sensor produced them. +""" + +from __future__ import annotations + +import xarray as xr + +# Built-in specs for common products. The value is the decode rule; ``band`` is a +# hint for which raster band holds the QA when loading the data (it is ignored by +# ``qa_to_weight``, which receives the band directly). +QA_SPECS: dict[str, dict] = { + "MOD13Q1": {"band": "SummaryQA", "remap": {0: 1.0, 1: 0.5, 2: 0.0, 3: 0.0}}, + "LANDSAT_C2": {"band": "QA_PIXEL", "bad_bits": [1, 2, 3, 4, 5]}, + "S2_SCL": {"band": "SCL", "good_classes": [4, 5, 6]}, +} + + +def list_qa_specs() -> list[str]: + """Return the names of the built-in QA specs.""" + return sorted(QA_SPECS) + + +def get_qa_spec(name: str) -> dict: + """Return the built-in QA spec registered under ``name``.""" + try: + return QA_SPECS[name] + except KeyError: + raise ValueError( + f"Unknown QA spec {name!r}; choose from {list_qa_specs()} or pass a dict/callable." + ) from None + + +def _remap(qa: xr.DataArray, mapping: dict, default: float) -> xr.DataArray: + out = xr.full_like(qa, float(default), dtype=float) + for value, weight in mapping.items(): + out = out.where(qa != value, float(weight)) # set out=weight where qa==value + return out + + +def _good_classes(qa: xr.DataArray, classes) -> xr.DataArray: + return qa.isin(list(classes)).astype(float) # NaN is not in the list -> 0 + + +def _bad_bits(qa: xr.DataArray, bits) -> xr.DataArray: + mask = int(sum(1 << int(b) for b in bits)) + qi = qa.fillna(-1).astype("int64") # -1 has all bits set -> flagged bad + good = (qi & mask) == 0 + return good.astype(float).where(qa.notnull(), 0.0) + + +def _threshold(qa: xr.DataArray, lo, hi) -> xr.DataArray: + out = xr.ones_like(qa, dtype=float) + if hi is not None: + out = out.where(qa <= hi, 0.0) + if lo is not None: + out = out.where(qa >= lo, 0.0) + return out.where(qa.notnull(), 0.0) + + +def qa_to_weight(qa: xr.DataArray, spec) -> xr.DataArray: + """Decode a QA ``DataArray`` into weights in ``[0, 1]`` (same shape as ``qa``). + + Parameters + ---------- + qa: + The raw quality band, as an xarray ``DataArray``. + spec: + How to decode it -- one of: + + - a built-in registry key (see :func:`list_qa_specs`), e.g. ``"S2_SCL"``; + - a declarative ``dict`` with exactly one of ``remap`` (+ optional + ``default``), ``good_classes``, ``bad_bits``, or ``max_value`` / + ``min_value``; + - a callable ``qa -> weights`` for encodings that fit no pattern. + + Returns + ------- + xarray.DataArray + Weights in ``[0, 1]`` named ``"weight"``, aligned to ``qa``. + """ + if callable(spec): + return spec(qa) + if isinstance(spec, str): + spec = get_qa_spec(spec) + if not isinstance(spec, dict): + raise TypeError("spec must be a registry key (str), a dict, or a callable") + + if "remap" in spec: + out = _remap(qa, spec["remap"], spec.get("default", 0.0)) + elif "good_classes" in spec: + out = _good_classes(qa, spec["good_classes"]) + elif "bad_bits" in spec: + out = _bad_bits(qa, spec["bad_bits"]) + elif "max_value" in spec or "min_value" in spec: + out = _threshold(qa, spec.get("min_value"), spec.get("max_value")) + else: + raise ValueError( + "spec dict must contain one of: 'remap', 'good_classes', 'bad_bits', " + f"'max_value'/'min_value'; got keys {list(spec)}." + ) + return out.rename("weight") diff --git a/phenosensing/reconstruction.py b/phenosensing/reconstruction.py new file mode 100644 index 0000000..fd2cf07 --- /dev/null +++ b/phenosensing/reconstruction.py @@ -0,0 +1,255 @@ +"""Reconstruction (smoothing / curve-fitting) methods -- axis 1 of the +composable pipeline. + +A *reconstructor* maps an irregular ``(doy, value)`` series onto a regular grid +``xnew`` and returns the reconstructed values. All share the signature:: + + reconstruct(x, y, xnew, **params) -> ynew + +where ``x`` is the (sorted) day-of-year, ``y`` the vegetation-index values and +``xnew`` the regular output grid. + +New methods are registered in :data:`RECONSTRUCTORS`; unknown names fall back to +``scipy.interpolate.interp1d`` with the name used as the spline ``kind`` (for +backwards compatibility with the historical ``interpolType`` argument). + +Parametric fits (double-logistic, asymmetric Gaussian) are reimplemented from +the primary literature and return an all-NaN curve when the per-pixel fit fails +to converge, so they are safe to map over a whole raster. + +References +---------- +- Beck et al. (2006), Remote Sensing of Environment 100:321-334. +- Elmore et al. (2012), Global Change Biology 18:656-674. +- Jonsson & Eklundh (2002), IEEE TGRS 40:1824-1832 (asymmetric Gaussian). +- Eilers (2003), Analytical Chemistry 75:3631-3636 (Whittaker smoother). +""" + +from __future__ import annotations + +import numpy as np +from scipy.interpolate import Rbf, interp1d +from scipy.optimize import curve_fit +from scipy.signal import savgol_filter + +# --------------------------------------------------------------------------- # +# Interpolators (historical methods) +# --------------------------------------------------------------------------- # + + +def _linear(x, y, xnew, **params): + return np.interp(xnew, x, y) + + +def _rbf(x, y, xnew, function="cubic", **params): + return Rbf(x, y, function=function)(xnew) + + +def _kde(x, y, xnew, **params): + return _KDE(x, y, len(xnew)) + + +# --------------------------------------------------------------------------- # +# Smoothers (operate on a linearly-resampled regular grid) +# --------------------------------------------------------------------------- # + + +def _odd_window(window_length, n, polyorder): + """Coerce ``window_length`` to a valid odd Savitzky-Golay window for ``n`` points.""" + wl = int(min(window_length, n if n % 2 else n - 1)) + wl = max(wl, polyorder + 1) + if wl % 2 == 0: + wl += 1 + return min(wl, n if n % 2 else n - 1) + + +def _savgol(x, y, xnew, window_length=7, polyorder=2, **params): + base = np.interp(xnew, x, y) + wl = _odd_window(window_length, len(base), polyorder) + po = min(polyorder, wl - 1) + return savgol_filter(base, wl, po) + + +def _whittaker(x, y, xnew, lmbd=10.0, order=2, weights=None, **params): + from whittaker_eilers import WhittakerSmoother + + if weights is None: + base = np.interp(xnew, x, y) + smoother = WhittakerSmoother(lmbda=lmbd, order=order, data_length=len(base)) + return np.asarray(smoother.smooth(base), dtype=float) + + # Weighted: use per-observation weights (e.g. from a QA band). Pooled + # multi-year input has duplicate DOYs, so collapse each unique DOY to its + # weighted mean (with total weight) before smoothing the irregular series, + # then resample to the regular grid. + x = np.asarray(x, dtype=float) + y = np.asarray(y, dtype=float) + w = np.clip(np.asarray(weights, dtype=float), 0.0, None) + ux, inv = np.unique(x, return_inverse=True) + sw = np.bincount(inv, weights=w, minlength=ux.size) + swy = np.bincount(inv, weights=w * np.nan_to_num(y), minlength=ux.size) + uy = np.where(sw > 0, swy / np.where(sw > 0, sw, 1.0), np.interp(ux, x, y)) + smoother = WhittakerSmoother( + lmbda=lmbd, + order=order, + data_length=ux.size, + x_input=ux.tolist(), + weights=np.maximum(sw, 1e-6).tolist(), + ) + smoothed = np.asarray(smoother.smooth(uy.tolist()), dtype=float) + return np.interp(xnew, ux, smoothed) + + +def _upper_envelope(x, y, xnew, base="whittaker", n_iter=3, base_params=None, **params): + """Iterative upper-envelope reconstruction (Chen et al. 2004 / TIMESAT wTSM). + + Fits a base smoother, then repeatedly lifts below-fit samples -- assumed + cloud-contaminated, since clouds bias optical VIs *downward* -- up to the + fitted curve and refits, so the result tracks the noise-free upper envelope. + Needs no QA band; ``base`` is any registered reconstructor and ``base_params`` + its parameters (e.g. ``{"lmbd": 50}``). + """ + recon = get_reconstructor(base) + bp = dict(base_params or {}) + grid = np.interp(xnew, x, y) # work on the regular grid (no duplicate DOYs) + envelope = grid.copy() + for _ in range(max(int(n_iter), 1)): + fit = recon(xnew, envelope, xnew, **bp) + envelope = np.maximum(grid, fit) # keep where obs >= fit, else lift to the fit + return recon(xnew, envelope, xnew, **bp) + + +# --------------------------------------------------------------------------- # +# Parametric models (fitted per pixel) +# --------------------------------------------------------------------------- # + + +def _fit(model, x, y, xnew, p0, bounds, maxfev=10000): + """Fit ``model`` to ``(x, y)`` and evaluate at ``xnew``; NaN on failure.""" + try: + popt, _ = curve_fit(model, x, y, p0=p0, bounds=bounds, maxfev=maxfev) + return model(xnew, *popt) + except Exception: + return np.full(len(xnew), np.nan) + + +def _guess(x, y): + mn, mx = float(np.nanmin(y)), float(np.nanmax(y)) + amp = max(mx - mn, 1e-6) + half = mn + 0.5 * amp + above = x[y >= half] + sos0 = float(above.min()) if above.size else float(x[0]) + eos0 = float(above.max()) if above.size else float(x[-1]) + tpos = float(x[int(np.argmax(y))]) + return mn, mx, amp, sos0, eos0, tpos + + +def _beck(t, mn, mx, sos, rsp, eos, rau): + """Beck et al. (2006) double-logistic.""" + return mn + (mx - mn) * ( + 1.0 / (1.0 + np.exp(-rsp * (t - sos))) + 1.0 / (1.0 + np.exp(rau * (t - eos))) - 1.0 + ) + + +def _dlog_beck(x, y, xnew, **params): + mn, mx, amp, sos0, eos0, _ = _guess(x, y) + p0 = [mn, mx, sos0, 0.1, eos0, 0.1] + lo = [mn - amp, mn, float(x.min()), 0.0, float(x.min()), 0.0] + hi = [mx, mx + amp, float(x.max()), 1.0, float(x.max()), 1.0] + return _fit(_beck, x, y, xnew, p0, (lo, hi)) + + +def _elmore(t, m1, m2, m3, m4, m5, m6, m7): + """Elmore et al. (2012) seven-parameter double-logistic.""" + return m1 + (m2 - m7 * t) * ( + 1.0 / (1.0 + np.exp((m3 - t) / m4)) - 1.0 / (1.0 + np.exp((m5 - t) / m6)) + ) + + +def _dlog_elmore(x, y, xnew, **params): + mn, mx, amp, sos0, eos0, _ = _guess(x, y) + p0 = [mn, amp, sos0, 5.0, eos0, 5.0, 0.0] + lo = [mn - amp, 0.0, float(x.min()), 1e-2, float(x.min()), 1e-2, -abs(amp)] + hi = [mx, 2 * amp, float(x.max()), 1e3, float(x.max()), 1e3, abs(amp)] + return _fit(_elmore, x, y, xnew, p0, (lo, hi)) + + +def _asym_gauss(t, base, amp, t0, sig_l, sig_r): + """Asymmetric Gaussian: different widths on each side of the peak.""" + g = np.where( + t <= t0, + np.exp(-(((t - t0) / sig_l) ** 2)), + np.exp(-(((t - t0) / sig_r) ** 2)), + ) + return base + amp * g + + +def _agauss(x, y, xnew, **params): + mn, mx, amp, _, _, tpos = _guess(x, y) + span = max(float(x.max() - x.min()), 1.0) + p0 = [mn, amp, tpos, span / 4, span / 4] + lo = [mn - amp, 0.0, float(x.min()), 1e-2, 1e-2] + hi = [mx, 2 * amp, float(x.max()), span, span] + return _fit(_asym_gauss, x, y, xnew, p0, (lo, hi)) + + +# --------------------------------------------------------------------------- # +# Registry / dispatch +# --------------------------------------------------------------------------- # + +RECONSTRUCTORS = { + "linear": _linear, + "RBF": _rbf, + "KDE": _kde, + "savgol": _savgol, + "whittaker": _whittaker, + "dlog_beck": _dlog_beck, + "dlog_elmore": _dlog_elmore, + "agauss": _agauss, + "upper_envelope": _upper_envelope, +} + + +def list_reconstructors() -> list: + """Return the names of the registered reconstruction methods.""" + return sorted(RECONSTRUCTORS) + + +def get_reconstructor(name: str): + """Return the reconstructor callable for ``name``. + + Unknown names fall back to ``scipy.interpolate.interp1d`` using ``name`` as + the spline ``kind`` (e.g. ``"nearest"``, ``"quadratic"``, ``"cubic"``). + """ + if name in RECONSTRUCTORS: + return RECONSTRUCTORS[name] + + def _interp1d_kind(x, y, xnew, _kind=name, **params): + return interp1d(x, y, kind=_kind)(xnew) + + return _interp1d_kind + + +def _KDE(x, y, nGS): + """Bivariate KDE reconstruction using KDEpy (optional dependency).""" + try: + from KDEpy import FFTKDE + except ImportError as exc: + raise ImportError( + "KDE reconstruction requires the optional 'KDEpy' package. " + "Install it with `pip install KDEpy` (or the project's [kde] extra)." + ) from exc + + grid_points_x, grid_points_y = nGS + 6, 2**8 + data = np.vstack((x, y)).T + kde = FFTKDE(bw=0.025).fit(data) + grid, points = kde.evaluate((grid_points_x, grid_points_y)) + x2, y2 = np.unique(grid[:, 0]), np.unique(grid[:, 1]) + z = points.reshape(grid_points_x, grid_points_y) + y_pred = np.sum((z.T / np.sum(z, axis=1)).T * y2, axis=1) + idx = np.where(x2 < np.min(x)) + x2 = np.delete(x2, idx) + y_pred = np.delete(y_pred, idx) + idx = np.where(x2 > np.max(x)) + y_pred = np.delete(y_pred, idx) + return y_pred diff --git a/phenosensing/season.py b/phenosensing/season.py new file mode 100644 index 0000000..0392cf4 --- /dev/null +++ b/phenosensing/season.py @@ -0,0 +1,70 @@ +"""Multi-season detection (NOS, Number of Seasons). + +Counts the growing cycles in a reconstructed phenological curve per pixel, to +distinguish single-cycle vegetation from multi-cropping / bimodal systems. +Peaks are found with ``scipy.signal.find_peaks`` using a prominence threshold +relative to the per-pixel amplitude, so noise is not counted as a season. +""" + +from __future__ import annotations + +import numpy as np +import xarray as xr +from scipy.signal import find_peaks + + +def _count_peaks(curve, prominence_frac, distance, min_height_frac): + c = np.asarray(curve, dtype=float) + if np.isfinite(c).sum() < 3: + return np.nan + cmin = np.nanmin(c) + amp = np.nanmax(c) - cmin + if amp <= 0: + return 0.0 + prominence = prominence_frac * amp + height = cmin + min_height_frac * amp if min_height_frac is not None else None + peaks, _ = find_peaks(c, prominence=prominence, distance=distance, height=height) + return float(peaks.size) + + +def n_seasons(phenoshape, prominence=0.1, distance=None, min_height=None) -> xr.DataArray: + """Number of growing seasons (NOS) per pixel from a reconstructed curve. + + Parameters + ---------- + phenoshape: + A PhenoShape output with a ``doy`` dimension (or a ``doy`` coordinate on + a ``time`` dimension). + prominence: + Minimum peak prominence as a fraction of the per-pixel amplitude + (default 0.1 = 10%). Higher values count only the stronger seasons. + distance: + Optional minimum spacing between peaks, in samples of the ``doy`` grid. + min_height: + Optional minimum peak height as a fraction of the amplitude above the + per-pixel trough. + + Returns + ------- + xarray.DataArray + Per-pixel season count, dims ``(y, x)``. + """ + if "doy" not in phenoshape.dims: + if "doy" in phenoshape.coords and "time" in phenoshape.dims: + phenoshape = phenoshape.swap_dims({"time": "doy"}) + else: + raise ValueError("The provided DataArray must have 'doy' as a dimension or coordinate.") + + return xr.apply_ufunc( + _count_peaks, + phenoshape, + input_core_dims=[["doy"]], + kwargs={ + "prominence_frac": prominence, + "distance": distance, + "min_height_frac": min_height, + }, + vectorize=True, + dask="parallelized", + output_dtypes=[float], + ) diff --git a/phenosensing/trends.py b/phenosensing/trends.py new file mode 100644 index 0000000..77960fb --- /dev/null +++ b/phenosensing/trends.py @@ -0,0 +1,76 @@ +"""Temporal trend analysis on phenological metric time series. + +Computes, per pixel, the Theil-Sen slope and the Mann-Kendall significance of a +metric time series (e.g. one of the arrays returned by +:meth:`~phenosensing.phenosensing.Pheno.get_timeseries_metrics`). This is the layer that +turns the interannual moving-window series into a statement such as *"is the +start of season getting earlier, and is it significant?"*. + +The Mann-Kendall test is implemented directly (with the standard tie +correction), so trend analysis only needs numpy + scipy. +""" + +from __future__ import annotations + +import numpy as np +import xarray as xr +from scipy.stats import norm, theilslopes + + +def _mann_kendall_p(y: np.ndarray) -> float: + """Two-sided p-value of the Mann-Kendall trend test for a 1D series.""" + n = y.size + s = 0.0 + for k in range(n - 1): + s += np.sum(np.sign(y[k + 1 :] - y[k])) + _, counts = np.unique(y, return_counts=True) + var_s = (n * (n - 1) * (2 * n + 5) - np.sum(counts * (counts - 1) * (2 * counts + 5))) / 18.0 + if var_s <= 0: + return np.nan + if s > 0: + z = (s - 1) / np.sqrt(var_s) + elif s < 0: + z = (s + 1) / np.sqrt(var_s) + else: + z = 0.0 + return float(2 * (1 - norm.cdf(abs(z)))) + + +def _slope_pvalue(series: np.ndarray): + s = np.asarray(series, dtype=float) + mask = np.isfinite(s) + if mask.sum() < 4: # too few points for a meaningful trend + return np.nan, np.nan + t = np.arange(s.size)[mask] + slope = float(theilslopes(s[mask], t)[0]) + return slope, _mann_kendall_p(s[mask]) + + +def trend(da: xr.DataArray, dim: str = "time") -> xr.Dataset: + """Per-pixel Theil-Sen slope and Mann-Kendall p-value along ``dim``. + + Parameters + ---------- + da: + A metric time series, e.g. one of the arrays returned by + ``get_timeseries_metrics`` (dims ``(time, y, x)``). + dim: + Name of the temporal dimension. Default ``"time"``. + + Returns + ------- + xarray.Dataset + ``slope`` (metric units per time step, Theil-Sen estimator) and + ``p_value`` (Mann-Kendall, two-sided). Pixels with fewer than four + finite observations are NaN. + """ + slope, pval = xr.apply_ufunc( + _slope_pvalue, + da, + input_core_dims=[[dim]], + output_core_dims=[[], []], + vectorize=True, + dask="parallelized", + output_dtypes=[float, float], + ) + return xr.Dataset({"slope": slope, "p_value": pval}) diff --git a/phenosensing/uncertainty.py b/phenosensing/uncertainty.py new file mode 100644 index 0000000..222466e --- /dev/null +++ b/phenosensing/uncertainty.py @@ -0,0 +1,102 @@ +"""Per-metric uncertainty via bootstrap resampling. + +For each pixel, the observations are resampled with replacement ``n_boot`` +times; the 16 land-surface-phenology metrics are recomputed for every replicate +and their spread (standard deviation) is returned as the per-metric +uncertainty. This is a non-parametric estimate of the sampling uncertainty of +SOS/POS/EOS and the other metrics. +""" + +from __future__ import annotations + +import numpy as np +import xarray as xr + +from .utils import LSP_BANDS, _getLSPmetrics2, _getPheno0 + + +def _bootstrap_lsp_std( + vi, + doy, + n_boot, + interpolType, + nan_replace, + rollWindow, + nGS, + phentype, + extraction, + extract_params, + seed, +): + n_bands = len(LSP_BANDS) + if np.isfinite(vi).sum() < 3: + return np.full(n_bands, np.nan) + rng = np.random.default_rng(seed) + T = vi.shape[0] + boot = np.full((n_boot, n_bands), np.nan) + for b in range(n_boot): + idx = rng.integers(0, T, T) + d = doy[idx] + phen = _getPheno0(vi[idx], d, interpolType, nan_replace, rollWindow, nGS) + xnew = np.linspace(np.min(d), np.max(d), nGS, dtype=np.int32) + boot[b] = _getLSPmetrics2(phen, xnew, nGS, LSP_BANDS, phentype, extraction, extract_params) + return np.nanstd(boot, axis=0) + + +def uncertainty( + da: xr.DataArray, + n_boot: int = 50, + interpolType: str = "linear", + nan_replace: float | None = None, + rollWindow: int = 5, + nGS: int = 52, + phentype: int = 1, + extraction: str | None = None, + extract_params: dict | None = None, + seed: int = 0, +) -> xr.Dataset: + """Per-pixel bootstrap uncertainty (std) of each land-surface-phenology metric. + + Parameters + ---------- + da: + ``(time, y, x)`` vegetation-index cube with a ``doy`` coordinate. + n_boot: + Number of bootstrap replicates (resamples of the observations). + interpolType, nan_replace, rollWindow, nGS, phentype, extraction, + extract_params: + Passed through to the reconstruction/extraction for each replicate. + seed: + Seed for the per-pixel resampling (reproducible). + + Returns + ------- + xarray.Dataset + The bootstrap standard deviation of each of the 16 metrics, dims + ``(y, x)`` per variable. + """ + doy = np.asarray(da["doy"].values) + out = xr.apply_ufunc( + _bootstrap_lsp_std, + da, + input_core_dims=[["time"]], + output_core_dims=[["LSP_bands"]], + exclude_dims={"time"}, + vectorize=True, + dask="parallelized", + dask_gufunc_kwargs={"output_sizes": {"LSP_bands": len(LSP_BANDS)}}, + output_dtypes=[float], + kwargs={ + "doy": doy, + "n_boot": n_boot, + "interpolType": interpolType, + "nan_replace": nan_replace, + "rollWindow": rollWindow, + "nGS": nGS, + "phentype": phentype, + "extraction": extraction, + "extract_params": extract_params, + "seed": seed, + }, + ) + return out.assign_coords(LSP_bands=list(LSP_BANDS)).to_dataset("LSP_bands") diff --git a/phenosensing/utils.py b/phenosensing/utils.py new file mode 100644 index 0000000..2ce1df1 --- /dev/null +++ b/phenosensing/utils.py @@ -0,0 +1,340 @@ +import sys +from functools import reduce + +import numpy as np +import xarray as xr +from scipy.integrate import trapezoid +from scipy.stats import skew + +from .extraction import get_extractor +from .reconstruction import get_reconstructor + +# Canonical order of the 18 land-surface-phenology bands from _getLSPmetrics2. +LSP_BANDS = [ + "sos", + "pos", + "eos", + "vsos", + "vpos", + "veos", + "los", + "msp", + "mau", + "vmsp", + "vmau", + "ampl", + "ios", + "rog", + "ros", + "sw", + "trough", + "mos", +] + + +def reorder_southern_hemisphere(img: xr.Dataset) -> tuple: + """ + Reorder the DOY of the img for the Southern Hemisphere to ensure + peak summer is in the middle. This reordering is critical for some applications + like phenological studies. + + :param img: xarray Dataset with `time` and `doy` dimensions/coordinates. + :return: The input xarray Dataset reordered by DOY. + """ + doy = img.doy.values + time_values = img.time.values + + arr1 = np.linspace(183, 365, int(365 - 180)).astype(int) + arr2 = np.linspace(1, 185, 180).astype(int) + result = np.concatenate((arr1, arr2)) + positions = [np.where(result == value)[0][0] for value in doy] + + # Create a mapping of DOY value to its position in 'result' + position_map = {value: np.where(result == value)[0][0] for value in doy} + + # Reorder the time values based on the mapping + reordered_times = sorted( + time_values, key=lambda x: position_map[img.sel(time=x).doy.values.item()] + ) + + # Re-index the img using the reordered time values + da = img.sel(time=reordered_times) + da.doy.values = np.linspace(1, 365, len(da.time.values)) # np.sort(doy)# + + return positions, da + + +def _getPheno(y, x, nGS, interpolType, recon_params=None, weights=None): + """ + Reconstruct a regular phenological curve from an irregular (doy, value) series. + + x: DOY values + y: ndarray with VI values + interpolType: reconstruction method name (see ``phenosensing.reconstruction``) + recon_params: optional dict of method-specific parameters + weights: optional per-observation weights in [0, 1] (e.g. from a QA band), + passed to reconstructors that support them (e.g. ``whittaker``). + """ + inds = np.isnan(y) # check if array has NaN values + if np.sum(inds) == len(y): # check if all values are NaN + return y[0:nGS] + try: + xnew = np.linspace(np.min(x), np.max(x), nGS, dtype=np.int32) + if inds.any(): # if inds have at least one True + y = _fillNaN(y) + _replaceElements(x) # replace doy values when they are the same + reconstruct = get_reconstructor(interpolType) + # only forward ``weights`` when given, so the unweighted call is unchanged + extra = {} if weights is None else {"weights": weights} + ynew = reconstruct(x, y, xnew, **extra, **(recon_params or {})) + return ynew + except Exception as e: + print(f"An error occurred: {e}") + return np.full(nGS, np.nan) + + +def _getPheno0(y, doy, interpolType, nan_replace, rollWindow, nGS, recon_params=None, weights=None): + # replace nan_replace values by NaN + if nan_replace is not None: + y = np.where(y == nan_replace, np.nan, y) + + # sort values by DOY (and the weights alongside, when provided) + idx = doy.argsort() + y = y[idx] + w = weights[idx] if weights is not None else None + + # get phenological shape (reconstruction) + phen = _getPheno(y, doy[idx], nGS, interpolType, recon_params=recon_params, weights=w) + + # rolling average using moving window + if rollWindow is not None: + phen = _moving_average(phen, rollWindow) + + return phen + + +def _getPheno0_weighted(y, weights, doy, interpolType, nan_replace, rollWindow, nGS, recon_params=None): + """``_getPheno0`` with the weights as a second positional array, for the + two-input ``xr.apply_ufunc`` path used when ``PhenoShape(weights=...)``.""" + return _getPheno0( + y, doy, interpolType, nan_replace, rollWindow, nGS, + recon_params=recon_params, weights=weights, + ) + + +def _getLSPmetrics2(phen, xnew, nGS, bands, phentype=1, extraction=None, extract_params=None): + """ + Obtain land surfurface phenology metrics + + Parameters + ---------- + - phen: 1D array + PhenoShape data + - xnew: 1D array + DOY values for PhenoShape data + - bands: string list + Name of the output bands (soft requirement) + + Outputs + ------- + - 2D array with the following variables: + + SOS = DOY of start of season + POS = DOY of peak of season + EOS = DOY of end of season + vSOS = Value at start of season + vPOS = Value at peak of season + vEOS = Value at end of season + LOS = Length of season (DOY) + MSP = Mean spring (DOY) + MAU = Mean autum (DOY) + vMSP = Mean spring value + vMAU = Mean autum value + AOS = Amplitude of season (in value units) + IOS = Integral of season (SOS-EOS) + ROG = Rate of greening [slope SOS-POS] + ROS = Rate of senescence [slope POS-EOS] + SW = Skewness of growing season + TROUGH = Trough / base value (minimum of the curve, in value units) + MOS = Middle of season (DOY, midpoint between SOS and EOS) + """ + inds = np.isnan(phen) # check if array has NaN values + if inds.any(): # check is all values are NaN + return np.repeat(np.nan, len(bands)) + else: + # basic variables + vpos = np.max(phen) + trough = np.min(phen) + ampl = vpos - trough + + # get position of seasonal peak and trough + ipos = np.where(phen == vpos)[0] + pos = xnew[ipos] + + # scale annual time series to 0-1 + ratio = (phen - trough) / ampl + + # separate greening from senesence values + dev = np.gradient(ratio) # first derivative + greenup = np.zeros([ratio.shape[0]], dtype=bool) + greenup[dev > 0] = True + + # determine SOS / EOS via the selected extraction method (axis 3) + if extraction is None: + extraction = "seasonal_median" # historical phentype 1/2 behavior + sos, eos, isos, ieos = get_extractor(extraction)( + phen, xnew, ratio, greenup, ipos, **(extract_params or {}) + ) + if sos is None: + isos = 0 + sos = xnew[isos] + if eos is None: + ieos = len(xnew) - 1 + eos = xnew[ieos] + + # los: length of season + los = eos - sos + if los < 0: + los = np.nan + + # get MSP, MAU (independent from SOS and EOS) + + # mean spring + idx = np.mean(xnew[(xnew > sos) & (xnew < pos[0])]) + idx = (np.abs(xnew - idx)).argmin() # indexing value + msp = xnew[idx] # DOY of MGS + vmsp = phen[idx] # mgs value + + # mean autum + idx = np.mean(xnew[(xnew < eos) & (xnew > pos[0])]) + idx = (np.abs(xnew - idx)).argmin() # indexing value + mau = xnew[idx] # DOY of MGS + vmau = phen[idx] # mgs value + + # doy of growing season + green = xnew[(xnew > sos) & (xnew < eos)] + id_ = [] + for i in range(len(green)): + id_.append((xnew == green[i]).nonzero()[0]) + # TODO: move id_ generation to a list comprehension -> id_ = [(xnew == green[i]).nonzero()[0] for i in range(len(green))] + + # index of growing season + id = np.array([item for sublist in id_ for item in sublist]) + + # get intergral of green season + ios = trapezoid(phen[id], xnew[id]) if len(id) > 0 else np.nan + + # skewness of growing season + sw = skew(phen[id]) if len(id) > 0 else np.nan + + # rate of greening [slope SOS-POS] + rog = (vpos - phen[isos]) / (pos - sos) + + # rate of senescence [slope POS-EOS] + ros = (phen[ieos] - vpos) / (eos - pos) + + # middle of season: midpoint DOY between SOS and EOS (NaN when LOS is) + mos = (sos + eos) / 2.0 if not np.isnan(los) else np.nan + # trough/base value already computed above as ``trough = np.min(phen)`` + + metrics = np.array( + ( + sos, + pos[0], + eos, + phen[isos][0], + vpos, + phen[ieos][0], + los, + msp, + mau, + vmsp, + vmau, + ampl, + ios, + rog[0], + ros[0], + sw, + trough, + mos, + ) + ) + + return metrics + + +def _rmse(computed_stack, original_stack, normalized=False): + # Compute RMSE + N = len(computed_stack["doy"]) + squared_difference = (original_stack - computed_stack) ** 2 + mean_squared_error = squared_difference.sum("doy", keep_attrs=True, skipna=True) / N + rmse = mean_squared_error**0.5 + + if normalized: + minn = original_stack.min(dim="doy", skipna=True) + maxx = original_stack.max(dim="doy", skipna=True) + return rmse / (maxx - minn) + else: + return rmse + + +def computeChunkSize(arr, sizeMB=100, Z="time"): + """ + Return a per-dimension chunk dict targeting ~``sizeMB`` per chunk. + + The ``Z`` axis (default ``'time'``) is kept whole and the spatial + dimensions are split into roughly square tiles to hit the target size. + + :param arr: 3D xarray.DataArray. + :param sizeMB: approximate desired chunk size in MB. + :param Z: name of the Z axis. By default, 'time'. + """ + bmod = arr.dtype.itemsize + shape = arr.shape + if len(shape) != 3: + raise ValueError(f"DataArray dimensions should be 3, not {len(shape)}") + total_sizeMB = reduce(lambda a, b: a * b, shape) / 1000**2 * bmod + if total_sizeMB <= sizeMB: + return dict(zip(arr.dims, shape)) + # keep the Z axis whole, split the spatial dims into ~square tiles + z_len = arr.sizes[Z] + spatial_dims = [d for d in arr.dims if d != Z] + bytes_per_col = bmod * z_len + target_pixels = max(1, int(sizeMB * 1000**2 / bytes_per_col)) + side = max(1, int(target_pixels**0.5)) + chunk = {Z: z_len} + for d in spatial_dims: + chunk[d] = min(arr.sizes[d], side) + return chunk + + +def _moving_average(a, n=3): + out = np.convolve(a, np.ones(n), "valid") / n + return np.concatenate([a[: np.int32(n / 2)], out, a[-np.int32(n / 2) :]]) # add values of tail + + +def _fillNaN(x): + # Fill NaN data by linear interpolation + mask = np.isnan(x) + x[mask] = np.interp(np.flatnonzero(mask), np.flatnonzero(~mask), x[~mask]) + return x + + +def _replaceElements(arr): + """ + Replace monotonic vector values to avoid + interpolation errors + """ + s = [] + for i in range(len(arr)): + # check whether the element + # is repeated or not + if arr[i] not in s: + s.append(arr[i]) + else: + # find the next greatest element + for j in range(arr[i] + 1, sys.maxsize): + if j not in s: + arr[i] = j + s.append(j) + break diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..e031713 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,103 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +# Renamed from the original 'phenopy', which is taken on PyPI by an unrelated +# clinical-phenotyping tool. 'phenosensing' (Phenology + remote Sensing) is both +# the distribution and the import name. +name = "phenosensing" +dynamic = ["version"] +description = "Land surface phenology metrics from satellite image time series, built on xarray." +readme = "README.md" +requires-python = ">=3.10" +license = { file = "LICENSE.txt" } +authors = [{ name = "Javier Lopatin", email = "javierlopatin@gmail.com" }] +keywords = [ + "phenology", + "remote-sensing", + "vegetation", + "xarray", + "time-series", + "land-surface-phenology", +] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Topic :: Scientific/Engineering :: GIS", +] +dependencies = [ + "numpy", + "scipy>=1.6", + "pandas", + "xarray>=2023.1", + "rioxarray", + "rasterio", + "rasterstats", + "shapely", + "tqdm", + "dask[array]", +] + +[project.optional-dependencies] +plot = ["matplotlib", "folium", "pyproj"] +fit = ["whittaker-eilers", "pymannkendall"] +kde = ["KDEpy"] +fast = ["numba"] +# Google Earth Engine data access for the example notebooks (needs a GEE +# account + a Google Cloud project; auth is interactive, so this is not part +# of `all` and never runs in CI). +gee = ["earthengine-api", "xee", "netCDF4"] +test = ["pytest", "pytest-cov", "ruff"] +docs = ["mkdocs-material", "mkdocstrings[python]", "ipykernel", "nbconvert"] +all = ["phenosensing[plot,fit,kde,fast]"] + +[project.urls] +Homepage = "https://github.com/JavierLopatin/PhenoSensing" +Repository = "https://github.com/JavierLopatin/PhenoSensing" + +[tool.hatch.version] +path = "phenosensing/__init__.py" + +[tool.hatch.build.targets.wheel] +packages = ["phenosensing"] +# Ship only the small example rasters + date CSVs; keep big/decorative +# assets and the notebook out of the wheel. +exclude = [ + "phenosensing/ExampleData.ipynb", + "phenosensing/.ipynb_checkpoints", + "phenosensing/__pycache__", + "phenosensing/data/kndvi_186.tif", + "phenosensing/data/dates.txt", + "phenosensing/data/*.png", + "phenosensing/data/*.jpg", + "phenosensing/data/*.svg", +] + +[tool.hatch.build.targets.sdist] +exclude = [ + "phenosensing/ExampleData.ipynb", + "phenosensing/.ipynb_checkpoints", + "phenosensing/data/kndvi_186.tif", + "phenosensing/data/*.png", + "phenosensing/data/*.jpg", + "phenosensing/data/*.svg", + ".github", + "docs", +] + +[tool.ruff] +line-length = 100 +target-version = "py310" +# Don't touch the example notebook (user-maintained) or data files. +extend-exclude = ["*.ipynb", "phenosensing/data"] + +[tool.ruff.lint] +select = ["E", "F", "W", "I"] +# Many scientific expressions are intentionally long; don't fail on length. +ignore = ["E501"] + +[tool.pytest.ini_options] +testpaths = ["tests"] diff --git a/tests/golden/_generate.py b/tests/golden/_generate.py new file mode 100644 index 0000000..4464395 --- /dev/null +++ b/tests/golden/_generate.py @@ -0,0 +1,32 @@ +"""Regenerate the golden LSP snapshots used by ``tests/test_golden.py``. + +Run from the repo root:: + + python tests/golden/_generate.py + +Only regenerate when a change to the numerical output is *intended* and +reviewed; otherwise the golden snapshots are the regression baseline. +""" + +from pathlib import Path + +import numpy as np + +import phenosensing # noqa: F401 (registers the `pheno` accessor) +from phenosensing.io import load_sample + +OUT = Path(__file__).parent +PHENOSHAPE_PARAMS = dict(interpolType="linear", rollWindow=5, nGS=52) + + +def main() -> None: + for name in ["SIF", "ndvi"]: + da = load_sample(name) + lsp = da.pheno.PhenoShape(**PHENOSHAPE_PARAMS).pheno.PhenoLSP().compute() + arrs = {str(b): lsp[b].values for b in lsp.data_vars} + np.savez_compressed(OUT / f"lsp_{name}.npz", **arrs) + print(f"wrote lsp_{name}.npz ({len(arrs)} metrics)") + + +if __name__ == "__main__": + main() diff --git a/tests/golden/lsp_SIF.npz b/tests/golden/lsp_SIF.npz new file mode 100644 index 0000000..32442ec Binary files /dev/null and b/tests/golden/lsp_SIF.npz differ diff --git a/tests/golden/lsp_ndvi.npz b/tests/golden/lsp_ndvi.npz new file mode 100644 index 0000000..8a6e713 Binary files /dev/null and b/tests/golden/lsp_ndvi.npz differ diff --git a/tests/test_anomaly.py b/tests/test_anomaly.py new file mode 100644 index 0000000..1cb66b2 --- /dev/null +++ b/tests/test_anomaly.py @@ -0,0 +1,47 @@ +"""Tests for non-parametric phenological anomaly detection.""" + +import numpy as np +import pandas as pd +import xarray as xr + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing.anomaly import anomaly + + +def _cube_with_low_year(ny=2, nx=2, anomalous_year=2019): + """5 years of weekly data; one year is anomalously low everywhere.""" + times = pd.date_range("2017-01-01", periods=5 * 46, freq="8D") + doy = times.dayofyear.values + year = times.year.values + season = 0.3 + 0.4 * np.sin((doy / 365.0) * 2 * np.pi - np.pi / 2) + base = np.broadcast_to(season[:, None, None], (len(times), ny, nx)).copy() + base[year == anomalous_year] -= 0.2 # a clear negative anomaly + da = xr.DataArray( + base, + dims=("time", "y", "x"), + coords={"time": times, "y": np.arange(ny), "x": np.arange(nx)}, + ) + return da.assign_coords(doy=("time", doy), year=("time", year)) + + +def test_anomaly_outputs(): + da = _cube_with_low_year() + out = anomaly(da, nGS=46, rollWindow=3) + assert {"anomaly", "rfd", "z"}.issubset(set(map(str, out.data_vars))) + for v in ("anomaly", "rfd", "z"): + assert set(out[v].dims) == {"time", "y", "x"} + # RFD is a percentile in (0, 1] + rfd = out["rfd"].values + assert np.nanmin(rfd) >= 0 and np.nanmax(rfd) <= 1 + + +def test_anomaly_detects_low_year(): + da = _cube_with_low_year(anomalous_year=2019) + out = anomaly(da, nGS=46, rollWindow=3) + + a2019 = out["anomaly"].where(da.year == 2019, drop=True).mean().item() + rfd2019 = out["rfd"].where(da.year == 2019, drop=True).mean().item() + rfd_other = out["rfd"].where(da.year != 2019, drop=True).mean().item() + + assert a2019 < -0.05 # clearly negative deviation in the dry year + assert rfd2019 < rfd_other # and it ranks as more extreme (lower percentile) diff --git a/tests/test_extraction.py b/tests/test_extraction.py new file mode 100644 index 0000000..c67b2ff --- /dev/null +++ b/tests/test_extraction.py @@ -0,0 +1,53 @@ +"""Unit tests for the SOS/EOS extraction registry (axis 3).""" + +import numpy as np +import pytest + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing.extraction import get_extractor, list_extractors +from phenosensing.io import load_sample + +METHODS = ["seasonal_median", "trs", "der", "curvature"] + + +def _synthetic_curve(): + xnew = np.linspace(1, 365, 60).astype(int) + phen = 0.2 + 0.6 * np.exp(-(((xnew - 180) / 45) ** 2)) + trough = phen.min() + ampl = phen.max() - trough + ratio = (phen - trough) / ampl + greenup = np.gradient(ratio) > 0 + ipos = np.where(phen == phen.max())[0] + return phen, xnew, ratio, greenup, ipos + + +def test_registry_lists_expected_methods(): + for m in METHODS: + assert m in list_extractors() + + +@pytest.mark.parametrize("method", METHODS) +def test_sos_before_pos_before_eos(method): + phen, xnew, ratio, greenup, ipos = _synthetic_curve() + sos, eos, _, _ = get_extractor(method)(phen, xnew, ratio, greenup, ipos) + pos = xnew[ipos[0]] + assert sos <= pos <= eos + + +def test_trs_crosses_threshold_at_sos(): + phen, xnew, ratio, greenup, ipos = _synthetic_curve() + _, _, isos, _ = get_extractor("trs")(phen, xnew, ratio, greenup, ipos, threshold=0.5) + assert ratio[int(isos[0])] >= 0.5 - 1e-9 + + +def test_unknown_method_raises(): + with pytest.raises(ValueError): + get_extractor("not-a-method") + + +@pytest.mark.parametrize("method", METHODS) +def test_phenolsp_runs_with_each_extraction(method): + da = load_sample("ndvi") + shape = da.pheno.PhenoShape(rollWindow=3, nGS=40) + lsp = shape.pheno.PhenoLSP(extraction=method).compute() + assert {"sos", "pos", "eos"}.issubset(set(map(str, lsp.data_vars))) diff --git a/tests/test_golden.py b/tests/test_golden.py new file mode 100644 index 0000000..85f84f9 --- /dev/null +++ b/tests/test_golden.py @@ -0,0 +1,37 @@ +"""Golden regression tests. + +Freeze the land-surface-phenology metrics computed by the *current* code on the +bundled sample datasets, so any silent numerical drift fails the test. Regenerate +the ``.npz`` snapshots with ``tests/golden/_generate.py`` only when a change to the +output is intended and reviewed (as when ``trough``/``mos`` were added). +""" + +from pathlib import Path + +import numpy as np +import pytest + +import phenosensing # noqa: F401 (importing registers the `pheno` accessor) +from phenosensing.io import load_sample + +GOLDEN_DIR = Path(__file__).parent / "golden" +PHENOSHAPE_PARAMS = dict(interpolType="linear", rollWindow=5, nGS=52) + + +@pytest.mark.parametrize("name", ["SIF", "ndvi"]) +def test_lsp_matches_golden(name): + da = load_sample(name) + lsp = da.pheno.PhenoShape(**PHENOSHAPE_PARAMS).pheno.PhenoLSP().compute() + + golden = np.load(GOLDEN_DIR / f"lsp_{name}.npz") + assert set(golden.files) == {str(v) for v in lsp.data_vars} + + for band in golden.files: + np.testing.assert_allclose( + lsp[band].values, + golden[band], + rtol=1e-5, + atol=1e-6, + equal_nan=True, + err_msg=f"{name}/{band} drifted from the golden snapshot", + ) diff --git a/tests/test_numba.py b/tests/test_numba.py new file mode 100644 index 0000000..cf74c0b --- /dev/null +++ b/tests/test_numba.py @@ -0,0 +1,37 @@ +"""The Numba fast path must match the pure-Python linear reconstruction.""" + +import numpy as np +import pandas as pd +import xarray as xr + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing import _numba + + +def _clean_cube(ny=4, nx=5, n=60): + """A small (time, y, x) cube with no NaNs (so the Numba path is eligible).""" + times = pd.date_range("2019-01-01", periods=n, freq="6D") + doy = times.dayofyear.values + season = 0.3 + 0.4 * np.sin((doy / 365.0) * 2 * np.pi - np.pi / 2) + data = np.broadcast_to(season[:, None, None], (n, ny, nx)).copy() + data += 0.01 * np.arange(ny * nx).reshape(1, ny, nx) # per-pixel variation + da = xr.DataArray( + data, + dims=("time", "y", "x"), + coords={"time": times, "y": np.arange(ny), "x": np.arange(nx)}, + ) + return da.assign_coords(doy=("time", doy), year=("time", times.year.values)) + + +def test_numba_linear_matches_pure_python(monkeypatch): + da = _clean_cube() + + numba_out = da.pheno.PhenoShape(interpolType="linear", rollWindow=5, nGS=40) + + # Force the pure-Python path and compare. + monkeypatch.setattr(_numba, "NUMBA_AVAILABLE", False) + python_out = da.pheno.PhenoShape(interpolType="linear", rollWindow=5, nGS=40) + + np.testing.assert_allclose( + numba_out.values, python_out.values, rtol=1e-5, atol=1e-6, equal_nan=True + ) diff --git a/tests/test_plotting.py b/tests/test_plotting.py new file mode 100644 index 0000000..23a7f8e --- /dev/null +++ b/tests/test_plotting.py @@ -0,0 +1,30 @@ +"""Smoke tests for the plotting helpers (Agg backend, no display).""" + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt # noqa: E402 + +from phenosensing.io import load_sample # noqa: E402 +from phenosensing.plotting import PhenoPlot # noqa: E402 + + +def _xy(da): + return float(da.x[da.sizes["x"] // 2]), float(da.y[da.sizes["y"] // 2]) + + +def test_phenoplot_southern_many_years_uses_colorbar(): + sif = load_sample("SIF") # 20 years -> continuous palette + colorbar + X, Y = _xy(sif) + ax = PhenoPlot(sif, X=X, Y=Y, rollWindow=5, ylab="SIF", southern=True) + assert ax.get_xlabel().lower().startswith("day of season") + assert ax.get_legend() is None # many years -> colorbar, not a legend + plt.close("all") + + +def test_phenoplot_few_years_uses_legend(): + ndvi = load_sample("ndvi") # 2 years -> per-year legend + X, Y = _xy(ndvi) + ax = PhenoPlot(ndvi, X=X, Y=Y, rollWindow=3) + assert ax.get_legend() is not None + plt.close("all") diff --git a/tests/test_qa.py b/tests/test_qa.py new file mode 100644 index 0000000..bf2fa1d --- /dev/null +++ b/tests/test_qa.py @@ -0,0 +1,66 @@ +"""Tests for the source-agnostic QA -> weight decoder (no Earth Engine needed).""" + +import numpy as np +import pytest +import xarray as xr + +from phenosensing.qa import list_qa_specs, qa_to_weight + + +def _da(vals): + return xr.DataArray(np.array(vals, dtype=float), dims=["time"], name="qa") + + +def test_remap_modis_summaryqa(): + # SummaryQA: 0 good -> 1, 1 marginal -> 0.5, 2 snow / 3 cloud -> 0 + w = qa_to_weight(_da([0, 1, 2, 3, 0]), "MOD13Q1") + assert list(w.values) == [1.0, 0.5, 0.0, 0.0, 1.0] + assert w.name == "weight" + + +def test_good_classes_s2_scl(): + # SCL: 4 veg, 5 bare, 6 water are kept; 8/9 cloud, 3 shadow, 11 snow dropped + w = qa_to_weight(_da([4, 5, 6, 8, 9, 3, 11]), "S2_SCL") + assert list(w.values) == [1, 1, 1, 0, 0, 0, 0] + + +def test_bad_bits_landsat_qa_pixel(): + # bad_bits = [1,2,3,4,5]; bit 6 is not flagged -> stays good + qa = _da([0, 1 << 3, 1 << 4, 1 << 6, 1 << 1]) + w = qa_to_weight(qa, "LANDSAT_C2") + assert list(w.values) == [1, 0, 0, 1, 0] + + +def test_threshold_dict_cloud_probability(): + # e.g. an S2 cloud-probability band: keep <= 30 % + w = qa_to_weight(_da([10, 30, 50, np.nan]), {"max_value": 30}) + assert list(w.values) == [1, 1, 0, 0] + + +def test_custom_callable(): + w = qa_to_weight(_da([0, 1, 2]), lambda q: q * 0 + 0.7) + assert float(w.mean()) == pytest.approx(0.7) + + +def test_nan_is_always_bad(): + assert list(qa_to_weight(_da([0, np.nan]), "MOD13Q1").values) == [1.0, 0.0] + + +def test_weights_preserve_dims_and_coords(): + qa = xr.DataArray( + np.zeros((3, 2, 2)), dims=["time", "y", "x"], coords={"time": [1, 2, 3]}, name="SCL" + ) + w = qa_to_weight(qa, "S2_SCL") + assert w.dims == qa.dims + assert list(w["time"].values) == [1, 2, 3] + + +def test_unknown_key_raises_listing_options(): + with pytest.raises(ValueError, match="Unknown QA spec"): + qa_to_weight(_da([0]), "NOPE") + assert "S2_SCL" in list_qa_specs() + + +def test_bad_dict_raises(): + with pytest.raises(ValueError, match="must contain one of"): + qa_to_weight(_da([0]), {"nonsense": 1}) diff --git a/tests/test_reconstruction.py b/tests/test_reconstruction.py new file mode 100644 index 0000000..473879a --- /dev/null +++ b/tests/test_reconstruction.py @@ -0,0 +1,53 @@ +"""Unit tests for the reconstruction registry (axis 1).""" + +import numpy as np + +from phenosensing.reconstruction import _beck, get_reconstructor, list_reconstructors + + +def test_registry_lists_expected_methods(): + names = list_reconstructors() + for m in ["linear", "RBF", "KDE", "savgol", "whittaker", "dlog_beck", "dlog_elmore", "agauss"]: + assert m in names + + +def test_linear_matches_numpy_interp(): + x = np.array([1.0, 10, 20, 40, 60]) + y = np.array([0.1, 0.5, 0.9, 0.4, 0.2]) + xnew = np.linspace(1, 60, 30) + out = get_reconstructor("linear")(x, y, xnew) + np.testing.assert_allclose(out, np.interp(xnew, x, y)) + + +def test_unknown_name_falls_back_to_interp1d_kind(): + x = np.array([1.0, 10, 20, 40, 60]) + y = np.array([0.1, 0.5, 0.9, 0.4, 0.2]) + xnew = np.linspace(1, 60, 10) + out = get_reconstructor("nearest")(x, y, xnew) + assert out.shape == xnew.shape + assert np.all(np.isfinite(out)) + + +def test_savgol_reduces_noise(): + rng = np.random.default_rng(0) + x = np.arange(1.0, 101.0) + clean = 0.5 + 0.4 * np.sin((x / 100) * 2 * np.pi - np.pi / 2) + y = clean + rng.normal(0, 0.05, x.size) + out = get_reconstructor("savgol")(x, y, x, window_length=11, polyorder=2) + assert np.var(np.diff(out)) < np.var(np.diff(y)) + + +def test_dlog_beck_recovers_known_curve(): + t = np.linspace(1, 365, 60) + truth = _beck(t, 0.1, 0.8, 120, 0.1, 270, 0.1) + out = get_reconstructor("dlog_beck")(t, truth, t) + assert np.all(np.isfinite(out)) + np.testing.assert_allclose(out, truth, atol=0.05) + + +def test_agauss_recovers_peak(): + t = np.linspace(1, 365, 60) + truth = 0.1 + 0.7 * np.exp(-(((t - 180) / 40) ** 2)) + out = get_reconstructor("agauss")(t, truth, t) + assert np.all(np.isfinite(out)) + assert abs(t[np.argmax(out)] - 180) < 30 diff --git a/tests/test_rmse_and_dask.py b/tests/test_rmse_and_dask.py new file mode 100644 index 0000000..a8e5861 --- /dev/null +++ b/tests/test_rmse_and_dask.py @@ -0,0 +1,50 @@ +"""RMSE regression tests and verification that the Dask (chunked) path matches +the eager path after the apply_ufunc refactor.""" + +import dask +import numpy as np +import pytest + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing.io import load_sample + + +def test_rmse_overall_and_segmented(): + da = load_sample("ndvi") + shape = da.pheno.PhenoShape(rollWindow=3, nGS=40) + lsp = shape.pheno.PhenoLSP() + + overall = shape.pheno.RMSE(da, LSP_stack=lsp, normalized=True) + assert "rmse" in overall.data_vars + + seg = shape.pheno.RMSE(da, LSP_stack=lsp, normalized=True, segment=True) + assert {"rmse", "rmse_sos", "rmse_pos", "rmse_eos"}.issubset(set(map(str, seg.data_vars))) + + +def test_rmse_requires_phenoshape_output(): + da = load_sample("ndvi") # has a 'time' dim, not a 'doy' dim + with pytest.raises(ValueError): + da.pheno.RMSE(da, LSP_stack=None) + + +def test_chunked_phenoshape_is_dask_and_matches_eager(): + da = load_sample("ndvi") + eager = da.pheno.PhenoShape(rollWindow=3, nGS=40) + lazy = da.pheno.PhenoShape(rollWindow=3, nGS=40, chunks={"x": 5, "y": 5}) + + assert dask.is_dask_collection(lazy.data) + np.testing.assert_allclose(eager.values, lazy.compute().values, equal_nan=True) + + +def test_chunked_phenolsp_matches_eager(): + da = load_sample("ndvi") + eager_lsp = da.pheno.PhenoShape(rollWindow=3, nGS=40).pheno.PhenoLSP() + lazy_lsp = ( + da.pheno.PhenoShape(rollWindow=3, nGS=40, chunks={"x": 5, "y": 5}) + .pheno.PhenoLSP() + .compute() + ) + for band in eager_lsp.data_vars: + np.testing.assert_allclose( + eager_lsp[band].values, lazy_lsp[band].values, rtol=1e-5, equal_nan=True + ) diff --git a/tests/test_season.py b/tests/test_season.py new file mode 100644 index 0000000..4a69620 --- /dev/null +++ b/tests/test_season.py @@ -0,0 +1,42 @@ +"""Tests for multi-season detection (NOS).""" + +import numpy as np +import xarray as xr + +from phenosensing.season import n_seasons + + +def _shape(curve): + xnew = np.linspace(1, 365, len(curve)).astype(int) + return xr.DataArray( + np.asarray(curve, dtype=float).reshape(-1, 1, 1), + dims=("doy", "y", "x"), + coords={"doy": xnew}, + ) + + +def test_bimodal_two_seasons(): + x = np.linspace(1, 365, 80) + curve = 0.2 + 0.5 * np.exp(-(((x - 100) / 25) ** 2)) + 0.5 * np.exp(-(((x - 260) / 25) ** 2)) + assert int(n_seasons(_shape(curve), prominence=0.1).isel(y=0, x=0)) == 2 + + +def test_unimodal_one_season(): + x = np.linspace(1, 365, 80) + curve = 0.2 + 0.6 * np.exp(-(((x - 180) / 40) ** 2)) + assert int(n_seasons(_shape(curve), prominence=0.1).isel(y=0, x=0)) == 1 + + +def test_flat_zero_seasons(): + assert float(n_seasons(_shape(np.full(60, 0.5))).isel(y=0, x=0)) == 0.0 + + +def test_accepts_time_dim_with_doy_coord(): + x = np.linspace(1, 365, 80) + curve = 0.2 + 0.6 * np.exp(-(((x - 180) / 40) ** 2)) + da = xr.DataArray( + curve.reshape(-1, 1, 1), + dims=("time", "y", "x"), + coords={"doy": ("time", x.astype(int))}, + ) + assert int(n_seasons(da, prominence=0.1).isel(y=0, x=0)) == 1 diff --git a/tests/test_smoke.py b/tests/test_smoke.py new file mode 100644 index 0000000..f773f23 --- /dev/null +++ b/tests/test_smoke.py @@ -0,0 +1,70 @@ +"""Smoke tests: the package imports, registers its accessor, and the core +PhenoShape -> PhenoLSP pipeline runs end to end on a tiny synthetic cube.""" + +import numpy as np +import pandas as pd +import xarray as xr + +import phenosensing # noqa: F401 (importing registers the `pheno` accessor) + +LSP_BANDS = [ + "sos", + "pos", + "eos", + "vsos", + "vpos", + "veos", + "los", + "msp", + "mau", + "vmsp", + "vmau", + "ampl", + "ios", + "rog", + "ros", + "sw", + "trough", + "mos", +] + + +def _synthetic_cube(ny=3, nx=4, years=3): + """A small (time, y, x) cube with a clean seasonal NDVI-like signal.""" + times = pd.date_range("2019-01-01", periods=23 * years, freq="16D") + doy = times.dayofyear.values + season = 0.4 + 0.3 * np.sin((doy / 365.0) * 2 * np.pi - np.pi / 2) + data = np.broadcast_to(season[:, None, None], (len(times), ny, nx)).copy() + da = xr.DataArray( + data, + dims=("time", "y", "x"), + coords={"time": times, "y": np.arange(ny), "x": np.arange(nx)}, + ) + return da.assign_coords(doy=("time", doy), year=("time", times.year.values)) + + +def test_package_has_version(): + assert isinstance(phenosensing.__version__, str) + + +def test_accessor_is_registered(): + da = xr.DataArray(np.zeros((5, 2, 2)), dims=("time", "y", "x")) + assert hasattr(da, "pheno") + + +def test_phenoshape_then_phenolsp_pipeline(): + da = _synthetic_cube() + + shape = da.pheno.PhenoShape(nGS=20, rollWindow=3) + assert "doy" in shape.dims + + lsp = shape.pheno.PhenoLSP().compute() + + # All 18 land-surface-phenology bands are present... + assert set(lsp.data_vars) == set(LSP_BANDS) + # ...spatial dims are preserved... + assert lsp.sizes["y"] == da.sizes["y"] + assert lsp.sizes["x"] == da.sizes["x"] + # ...and the peak-of-season falls within a plausible DOY range. + pos = float(lsp["pos"].isel(y=0, x=0)) + assert 1 <= pos <= 366 diff --git a/tests/test_timeseries.py b/tests/test_timeseries.py new file mode 100644 index 0000000..69d7838 --- /dev/null +++ b/tests/test_timeseries.py @@ -0,0 +1,26 @@ +"""Smoke test for the interannual moving-window orchestrator and that the +reconstruction/extraction axes are threaded through it.""" + +import numpy as np + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing.io import load_sample + + +def test_get_timeseries_metrics_runs_and_threads_extraction(): + da = load_sample("SIF").isel(y=slice(0, 3), x=slice(0, 3)) + years = np.unique(da.year.values)[:5] + da = da.where(da.year.isin(years), drop=True) + + ts = da.pheno.get_timeseries_metrics( + window_length=3, + metric=["sos", "pos", "eos"], + nGS=30, + extraction="trs", + ) + + assert set(ts) == {"sos", "pos", "eos"} + for key in ts: + assert "time" in ts[key].dims + # one value per sliding 3-year window over 5 years -> 3 windows + assert ts[key].sizes["time"] == 3 diff --git a/tests/test_trends.py b/tests/test_trends.py new file mode 100644 index 0000000..85849e3 --- /dev/null +++ b/tests/test_trends.py @@ -0,0 +1,32 @@ +"""Unit tests for trend analysis (Theil-Sen slope + Mann-Kendall).""" + +import numpy as np +import xarray as xr + +from phenosensing.trends import trend + + +def _series(values): + arr = np.asarray(values, dtype=float).reshape(-1, 1, 1) + return xr.DataArray(arr, dims=("time", "y", "x")) + + +def test_increasing_series_is_positive_and_significant(): + out = trend(_series(np.arange(12))) + assert float(out["slope"].isel(y=0, x=0)) > 0 + assert float(out["p_value"].isel(y=0, x=0)) < 0.05 + + +def test_decreasing_series_is_negative(): + out = trend(_series(np.arange(12)[::-1])) + assert float(out["slope"].isel(y=0, x=0)) < 0 + + +def test_flat_series_has_zero_slope(): + out = trend(_series(np.ones(10))) + assert abs(float(out["slope"].isel(y=0, x=0))) < 1e-9 + + +def test_too_short_series_is_nan(): + out = trend(_series([1.0, 2.0])) + assert np.isnan(float(out["slope"].isel(y=0, x=0))) diff --git a/tests/test_uncertainty.py b/tests/test_uncertainty.py new file mode 100644 index 0000000..f8aa5d1 --- /dev/null +++ b/tests/test_uncertainty.py @@ -0,0 +1,22 @@ +"""Tests for bootstrap per-metric uncertainty.""" + +import numpy as np + +import phenosensing # noqa: F401 (registers the accessor) +from phenosensing.io import load_sample +from phenosensing.uncertainty import uncertainty +from phenosensing.utils import LSP_BANDS + + +def test_uncertainty_structure_and_reproducible(): + da = load_sample("ndvi").isel(y=slice(0, 4), x=slice(0, 4)) + + u1 = uncertainty(da, n_boot=12, nGS=30, seed=0) + assert set(LSP_BANDS).issubset(set(map(str, u1.data_vars))) + assert set(u1["sos"].dims) == {"y", "x"} + # a standard deviation is non-negative (where finite) + assert float(np.nanmin(u1["sos"].values)) >= 0.0 + + # same seed -> identical result + u2 = uncertainty(da, n_boot=12, nGS=30, seed=0) + np.testing.assert_allclose(u1["sos"].values, u2["sos"].values, equal_nan=True) diff --git a/tests/test_weighted.py b/tests/test_weighted.py new file mode 100644 index 0000000..d849aa2 --- /dev/null +++ b/tests/test_weighted.py @@ -0,0 +1,93 @@ +"""Weighted reconstruction: QA-weighted Whittaker + upper-envelope (wTSM/Chen). + +Uses a synthetic clean season with injected *downward* "cloud" contamination +(the asymmetric noise QA weighting is meant to fix), so it needs no Earth Engine. +""" + +import numpy as np +import xarray as xr + +import phenosensing # noqa: F401 (registers the .pheno accessor) +from phenosensing.reconstruction import get_reconstructor, list_reconstructors + + +def _truth(doy): + """A clean single-season bump in [0.2, 0.9].""" + doy = np.asarray(doy, dtype=float) + return 0.2 + 0.7 * np.exp(-(((doy - 200.0) / 45.0) ** 2)) + + +def _contaminated(seed=0, n_years=5, frac=0.4): + """Pooled multi-year series (duplicate DOYs); a fraction of points are pulled + downward (clouds) and flagged with weight 0.""" + rng = np.random.default_rng(seed) + doy = np.sort(np.tile(np.arange(8, 361, 8, dtype=float), n_years)) + y = _truth(doy) + w = np.ones_like(y) + mask = rng.random(y.size) < frac + y = y.copy() + y[mask] -= 0.3 + 0.4 * rng.random(int(mask.sum())) # clouds bias NDVI down + w[mask] = 0.0 + return doy, y, w + + +def _rmse(a, b): + return float(np.sqrt(np.nanmean((np.asarray(a) - np.asarray(b)) ** 2))) + + +XNEW = np.arange(8, 361, 4, dtype=float) +TRUTH = _truth(XNEW) + + +def test_upper_envelope_is_registered(): + assert "upper_envelope" in list_reconstructors() + + +def test_upper_envelope_recovers_from_downward_noise(): + doy, y, _ = _contaminated() + env = get_reconstructor("upper_envelope")( + doy, y, XNEW, base="whittaker", n_iter=5, base_params={"lmbd": 50} + ) + lin = get_reconstructor("linear")(doy, y, XNEW) + assert _rmse(env, TRUTH) < _rmse(lin, TRUTH) + + +def test_weighted_whittaker_beats_unweighted(): + doy, y, w = _contaminated() + wht = get_reconstructor("whittaker") + weighted = wht(doy, y, XNEW, lmbd=50, weights=w) + plain = wht(doy, y, XNEW, lmbd=50) + assert _rmse(weighted, TRUTH) < _rmse(plain, TRUTH) + + +def _cube(doy, y, w, ny=2, nx=2): + da = xr.DataArray( + np.broadcast_to(y[:, None, None], (y.size, ny, nx)).astype(float), + dims=["time", "y", "x"], + coords={"doy": ("time", doy), "year": ("time", np.zeros(doy.size, int))}, + ) + wda = xr.DataArray( + np.broadcast_to(w[:, None, None], (w.size, ny, nx)).astype(float), + dims=["time", "y", "x"], + coords={"doy": ("time", doy)}, + ) + return da, wda + + +def test_phenoshape_weights_runs_and_improves_fit(): + doy, y, w = _contaminated() + da, wda = _cube(doy, y, w) + sw = da.pheno.PhenoShape( + interpolType="whittaker", recon_params={"lmbd": 50}, rollWindow=None, weights=wda + ) + su = da.pheno.PhenoShape(interpolType="whittaker", recon_params={"lmbd": 50}, rollWindow=None) + assert dict(sw.sizes)["doy"] == 52 + assert not np.allclose(sw.values, su.values) # weighting changed the result + truth = _truth(sw["doy"].values) + assert _rmse(sw.isel(y=0, x=0).values, truth) < _rmse(su.isel(y=0, x=0).values, truth) + + +def test_phenoshape_default_byte_identical_to_weights_none(): + doy, y, w = _contaminated() + da, _ = _cube(doy, y, w) + xr.testing.assert_identical(da.pheno.PhenoShape(), da.pheno.PhenoShape(weights=None))