From a0c60dbec000e5ebcb6a6a7d32d18d5c42f8785c Mon Sep 17 00:00:00 2001 From: ClaireP Date: Fri, 15 Dec 2023 17:02:09 +1100 Subject: [PATCH] updated requirements.in and ensemble tide modelling for exposure (#38) * updated requirements.in and ensemble tide modelling for exposure * Rearranged exposure.py to move active function to top of the script --- intertidal/elevation.py | 240 ++-- intertidal/exposure.py | 875 +++++++++++++- intertidal/tide_modelling.py | 127 ++ notebooks/Intertidal_workflow.ipynb | 1716 +++++++++++++++++++++++++-- requirements.in | 3 +- 5 files changed, 2762 insertions(+), 199 deletions(-) create mode 100644 intertidal/tide_modelling.py diff --git a/intertidal/elevation.py b/intertidal/elevation.py index ba89cbb..58cad94 100644 --- a/intertidal/elevation.py +++ b/intertidal/elevation.py @@ -37,6 +37,7 @@ round_date_strings, export_intertidal_rasters, ) +from intertidal.tide_modelling import pixel_tides_ensemble from intertidal.extents import extents from intertidal.exposure import exposure from intertidal.tidal_bias_offset import bias_offset, tidal_offset_tidelines @@ -487,119 +488,132 @@ def load_topobathy( return topobathy_ds -def pixel_tides_ensemble( - satellite_ds, - directory, - ancillary_points, - top_n=3, - models=None, - interp_method="nearest", -): - """ - Generate an ensemble tide model, choosing the best three tide models - for any coastal location using ancillary point data (e.g. altimetry - observations or NDWI correlations along the coastline). - - This function generates an ensemble of tidal height predictions for - each pixel in a satellite dataset. Firstly, tides from multiple tide - models are modelled into a low resolution grid using `pixel_tides`. - Ancillary point data is then loaded and interpolated to the same - grid to serve as weightings. These weightings are used to retain - only the top three tidal models, and remaining top models are - combined into a single ensemble output for each time/x/y. - The resulting ensemble tides are then resampled and reprojected to - match the high-resolution satellite data. - - Parameters: - ----------- - satellite_ds : xarray.Dataset - Three-dimensional dataset containing satellite-derived - information (x by y by time). - directory : str - Directory containing tidal model data; see `pixel_tides`. - ancillary_points : str - Path to a file containing point correlations for different tidal - models. - top_n : integer, optional - The number of top models to use in the ensemble calculation. - Default is 3, which will calculate a median of the top 3 models. - models : list or None, optional - An optional list of tide models to use for the ensemble model. - Default is None, which will use "FES2014", "FES2012", "EOT20", - "TPXO8-atlas-v1", "TPXO9-atlas-v5", "HAMTIDE11", "GOT4.10". - interp_method : str, optional - Interpolation method used to interpolate correlations onto the - low-resolution tide grid. Default is "nearest". - - Returns: - -------- - tides_highres : xarray.Dataset - High-resolution ensemble tidal heights dataset. - weights_ds : xarray.Dataset - Dataset containing weights for each tidal model used in the ensemble. - """ - # Use default models if none provided - if models is None: - models = [ - "FES2014", - "FES2012", - "TPXO8-atlas-v1", - "TPXO9-atlas-v5", - "EOT20", - "HAMTIDE11", - "GOT4.10", - ] - - # Model tides into every pixel in the three-dimensional - # (x by y by time) satellite dataset - tide_lowres = pixel_tides( - satellite_ds, - resample=False, - model=models, - directory=directory, - ) - - # Load ancillary points from file, reproject to match satellite - # data, and drop empty points - print("Generating ensemble tide model from point inputs") - corr_gdf = ( - gpd.read_file(ancillary_points)[models + ["geometry"]] - .to_crs(satellite_ds.odc.crs) - .dropna() - ) - - # Loop through each model, interpolating correlations into - # low-res tide grid - out_list = [] - - for model in models: - out = interpolate_2d( - tide_lowres, - x_coords=corr_gdf.geometry.x, - y_coords=corr_gdf.geometry.y, - z_coords=corr_gdf[model], - method=interp_method, - ).expand_dims({"tide_model": [model]}) - - out_list.append(out) - - # Combine along tide model dimension into a single xarray.Dataset - weights_ds = xr.concat(out_list, dim="tide_model") - - # Mask out all but the top N models, then take median of remaining - # to produce a single ensemble output for each time/x/y - tide_lowres_ensemble = tide_lowres.where( - (weights_ds.rank(dim="tide_model") > (len(models) - top_n)) - ).median("tide_model") - - # Resample/reproject ensemble tides to match high-res satellite data - tides_highres, tides_lowres = _pixel_tides_resample( - tides_lowres=tide_lowres_ensemble, - ds=satellite_ds, - ) - - return tides_highres, weights_ds - +# def pixel_tides_ensemble( +# satellite_ds, +# directory, +# ancillary_points, +# times=None, +# top_n=3, +# models=None, +# interp_method="nearest", +# ): +# """ +# Generate an ensemble tide model, choosing the best three tide models +# for any coastal location using ancillary point data (e.g. altimetry +# observations or NDWI correlations along the coastline). + +# This function generates an ensemble of tidal height predictions for +# each pixel in a satellite dataset. Firstly, tides from multiple tide +# models are modelled into a low resolution grid using `pixel_tides`. +# Ancillary point data is then loaded and interpolated to the same +# grid to serve as weightings. These weightings are used to retain +# only the top three tidal models, and remaining top models are +# combined into a single ensemble output for each time/x/y. +# The resulting ensemble tides are then resampled and reprojected to +# match the high-resolution satellite data. + +# Parameters: +# ----------- +# satellite_ds : xarray.Dataset +# Three-dimensional dataset containing satellite-derived +# information (x by y by time). +# directory : str +# Directory containing tidal model data; see `pixel_tides`. +# ancillary_points : str +# Path to a file containing point correlations for different tidal +# models. +# times : tuple or None, optional +# Tuple containing start and end time of time range to be used for +# tide model in the format of "YYYY-MM-DD". +# top_n : integer, optional +# The number of top models to use in the ensemble calculation. +# Default is 3, which will calculate a median of the top 3 models. +# models : list or None, optional +# An optional list of tide models to use for the ensemble model. +# Default is None, which will use "FES2014", "FES2012", "EOT20", +# "TPXO8-atlas-v1", "TPXO9-atlas-v5", "HAMTIDE11", "GOT4.10". +# interp_method : str, optional +# Interpolation method used to interpolate correlations onto the +# low-resolution tide grid. Default is "nearest". + +# Returns: +# -------- +# tides_highres : xarray.Dataset +# High-resolution ensemble tidal heights dataset. +# weights_ds : xarray.Dataset +# Dataset containing weights for each tidal model used in the ensemble. +# """ +# # Use default models if none provided +# if models is None: +# models = [ +# "FES2014", +# "FES2012", +# "TPXO8-atlas-v1", +# "TPXO9-atlas-v5", +# "EOT20", +# "HAMTIDE11", +# "GOT4.10", +# ] + +# # Model tides into every pixel in the three-dimensional +# # (x by y by time) satellite dataset + +# if times is None: +# tide_lowres = pixel_tides( +# satellite_ds, +# resample=False, +# model=models, +# directory=directory, +# ) +# else: +# tide_lowres = pixel_tides( +# satellite_ds, +# resample=False, +# times=times, +# model=models, +# directory=directory, +# ) + +# # Load ancillary points from file, reproject to match satellite +# # data, and drop empty points +# print("Generating ensemble tide model from point inputs") +# corr_gdf = ( +# gpd.read_file(ancillary_points)[models + ["geometry"]] +# .to_crs(satellite_ds.odc.crs) +# .dropna() +# ) + +# # Loop through each model, interpolating correlations into +# # low-res tide grid +# out_list = [] + +# for model in models: +# out = interpolate_2d( +# tide_lowres, +# x_coords=corr_gdf.geometry.x, +# y_coords=corr_gdf.geometry.y, +# z_coords=corr_gdf[model], +# method=interp_method, +# ).expand_dims({"tide_model": [model]}) + +# out_list.append(out) + +# # Combine along tide model dimension into a single xarray.Dataset +# weights_ds = xr.concat(out_list, dim="tide_model") + +# # Mask out all but the top N models, then take median of remaining +# # to produce a single ensemble output for each time/x/y +# tide_lowres_ensemble = tide_lowres.where( +# (weights_ds.rank(dim="tide_model") > (len(models) - top_n)) +# ).median("tide_model") + +# # Resample/reproject ensemble tides to match high-res satellite data +# tides_highres, tides_lowres = _pixel_tides_resample( +# tides_lowres=tide_lowres_ensemble, +# ds=satellite_ds, +# ) + +# return tides_highres, weights_ds def ds_to_flat( satellite_ds, diff --git a/intertidal/exposure.py b/intertidal/exposure.py index c5b1831..b5de122 100644 --- a/intertidal/exposure.py +++ b/intertidal/exposure.py @@ -1,14 +1,32 @@ import xarray as xr import numpy as np +import geopandas as gpd +# import pandas as pd -from dea_tools.coastal import pixel_tides +# from shapely.geometry import Point +# from shapely.ops import unary_union +# import sunriset +# from math import ceil +# import datetime +# from datetime import timedelta +# import pytz +# from pyproj import CRS +# from pyproj import Transformer +# from scipy.signal import argrelmax, argrelmin +from scipy.interpolate import interp1d + +from dea_tools.coastal import pixel_tides, model_tides +from intertidal.tide_modelling import pixel_tides_ensemble +# from intertidal.elevation import pixel_tides_ensemble +# from intertidal.utils import round_date_strings def exposure( dem, time_range, tide_model="FES2014", tide_model_dir="/var/share/tide_models", + ancillary_points="data/raw/corr_points.geojson" ): """ Calculate exposure percentage for each pixel based on tide-height @@ -64,9 +82,10 @@ def exposure( # For each pixel, an array of tideheights is returned, corresponding # to the percentiles from pc_range of the timerange-tide model that # each tideheight appears in the model. - tide_cq, _ = pixel_tides( + tide_cq, _ = pixel_tides_ensemble( dem, resample=True, + ancillary_points=ancillary_points, calculate_quantiles=pc_range, times=time_range, model=tide_model, @@ -86,3 +105,855 @@ def exposure( exposure = idxmin * 100 return exposure, tide_cq + +''' +The code below is currently in development to apply custom temporal +and spatial filters to the exposure calculation. +''' + +# def exposure( +# start_date, +# end_date, +# dem, +# time_range, +# mod_timesteps = None, +# tide_model="ensemble", +# tide_model_dir="/var/share/tide_models", +# # timezones = None, +# filters = None, ## Currently designed for a single output eg winter, low-tide. Needs some reworking to consider multiple outputs +# ): + +# """ +# Calculate exposure percentage for each pixel based on tide-height +# differences between the elevation value and percentile values of the +# tide model for a given time range. + +# Parameters +# ---------- +# start_date : str +# A four-digit single year string, should match the query and +# start_date used for the elevation calculation e.g. '2019' +# end_date : str +# A four-digit single year string, should match the query and +# end_date used for the elevation calculation e.g. '2021' +# dem : xarray.DataArray +# xarray.DataArray containing Digital Elevation Model (DEM) data +# and coordinates and attributes metadata. +# time_range : tuple +# Tuple containing start and end time of time range to be used for +# tide model in the format of "YYYY-MM-DD". +# tide_model : str, optional +# The tide model used to model tides, as supported by the `pyTMD` +# Python package. Options include: +# - "FES2014" (default; pre-configured on DEA Sandbox) +# - "TPXO8-atlas" +# - "TPXO9-atlas-v5" +# tide_model_dir : str, optional +# The directory containing tide model data files. Defaults to +# "/var/share/tide_models"; for more information about the +# directory structure, refer to `dea_tools.coastal.model_tides`. +# filters : list of strings, optional +# A list of customisation options to input into the tidal +# modelling to calculate exposure. Selections currently combine +# to produce a single exposure output e.g. winter, low-tide +# TODO: rework to product multiple outputs +# NOTE: do not input multiple temporal options as code is likely +# to fail e.g summer, June +# timezones : dict, optional +# For calculation of day and night exposure, timezones is a +# dictionary of paths to relevant timezone shapefiles for your +# area of interest. Defaults to None +# mod_timesteps : int +# Frequency used to run the tidal model in numpy timedelta64 format + +# Returns +# ------- +# exposure : xarray.DataArray +# An xarray.DataArray containing the percentage time 'exposure' of +# each pixel from seawater for the duration of the modelling +# period `timerange`. +# tide_cq : xarray.DataArray +# An xarray.DataArray containing the quantiled high temporal +# resolution tide modelling for each pixel. Dimesions should be +# 'quantile', 'x' and 'y'. + +# Notes +# ----- +# - The tide-height percentiles range from 0 to 100, divided into 101 +# equally spaced values. +# - The 'diff' variable is calculated as the absolute difference +# between tide model percentile value and the DEM value at each pixel. +# - The 'idxmin' variable is the index of the smallest tide-height +# difference (i.e., maximum similarity) per pixel and is equivalent +# to the exposure percent. +# """ + +# # Separate 'filters' into spatial and temporal categories to define +# # which exposure workflow to use +# temporal_filters = ['dry', 'wet', 'summer', 'autumn', 'winter', 'spring', 'Jan', 'Feb', 'Mar', 'Apr', +# 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Daylight', 'Night'] +# spatial_filters = ['Spring_high', 'Spring_low', 'Neap_high', 'Neap_low', 'Hightide', 'Lowtide'] + +# ## Set the required range of tide-height percentiles for exposure calculation +# calculate_quantiles = np.linspace(0, 1, 101) + +# ## Create empty datasets to store outputs into +# exposure = xr.Dataset(coords=dict(y=(['y'], dem.y.values), +# x=(['x'], dem.x.values))) +# tide_cq_dict = xr.Dataset(coords=dict(y=(['y'], dem.y.values), +# x=(['x'], dem.x.values))) +# ## Create an empty dict to store temporal `time_range` variables into +# timeranges = {} + +# ## Create an empty dict to store filtered datetimes into for testing against mixed/semi/diurnal tideranges +# filt_dt = {} + +# # ## For use with spatial filter options +# # #Run a full tidal model for each pixel +# # ModelledTides = pixel_tides( +# # dem,#ds, +# # times=time_range, +# # model=tide_model, +# # directory = tide_model_dir) + +# # Model tides into every pixel in the three-dimensional satellite +# # dataset (x by y by time) +# # log.info(f"{log_prefix}Modelling tide heights for each pixel") +# if (tide_model[0] == "ensemble") or (tide_model == "ensemble"): +# # Use ensemble model combining multiple input ocean tide models +# ModelledTides, _ = pixel_tides_ensemble( +# dem, +# times=time_range, +# directory=tide_model_dir, +# ancillary_points="data/raw/corr_points.geojson", +# ) + +# else: +# # Use single input ocean tide model +# ModelledTides, _ = pixel_tides( +# dem,#ds, +# times=time_range, +# model=tide_model, +# directory = tide_model_dir) + +# ## For use with spatial filter options +# ## stack the y and x dimensions +# stacked_everything = ModelledTides[0].stack(z=['y','x']).groupby('z') + +# # ## For use with spatial filter options ####TEMP: commented out to test ensemble tide modelling. No mod_timesteps var +# # # # Extract the modelling freq units +# # order=(int(mod_timesteps[0]/2)) + +# ## Temp: for tide-regime testing +# filt_dt['modelledtides'] = ModelledTides + +# # Filter the input timerange to include only dates or tide ranges of interest +# if filters is not None: +# for x in filters: +# if x in temporal_filters: + +# if x == 'dry': +# timeranges['dry_exp'] = time_range.drop(time_range[(time_range.month == 10) ## Wet season: Oct-Mar +# |(time_range.month == 11) +# |(time_range.month == 12) +# |(time_range.month == 1) +# |(time_range.month == 2) +# |(time_range.month == 3) +# ]) +# elif x == 'wet': +# timeranges['wet_exp'] = time_range.drop(time_range[(time_range.month == 4) ## Dry season: Apr-Sep +# |(time_range.month == 5) +# |(time_range.month == 6) +# |(time_range.month == 7) +# |(time_range.month == 8) +# |(time_range.month == 9) +# ]) +# elif x == 'summer': +# timeranges['summer_exp'] = time_range.drop(time_range[time_range.quarter != 1]) +# elif x == 'autumn': +# timeranges['autumn_exp'] = time_range.drop(time_range[time_range.quarter != 2]) +# elif x == 'winter': +# timeranges['winter_exp'] = time_range.drop(time_range[time_range.quarter != 3]) +# elif x == 'spring': +# timeranges['spring_exp'] = time_range.drop(time_range[time_range.quarter != 4]) +# elif x == 'Jan': +# timeranges['Jan_exp'] = time_range.drop(time_range[time_range.month != 1]) +# elif x == 'Feb': +# timeranges['Feb_exp'] = time_range.drop(time_range[time_range.month != 2]) +# elif x == 'Mar': +# timeranges['Mar_exp'] = time_range.drop(time_range[time_range.month != 3]) +# elif x == 'Apr': +# timeranges['Apr_exp'] = time_range.drop(time_range[time_range.month != 4]) +# elif x == 'May': +# timeranges['May_exp'] = time_range.drop(time_range[time_range.month != 5]) +# elif x == 'Jun': +# timeranges['Jun_exp'] = time_range.drop(time_range[time_range.month != 6]) +# elif x == 'Jul': +# timeranges['Jul_exp'] = time_range.drop(time_range[time_range.month != 7]) +# elif x == 'Aug': +# timeranges['Aug_exp'] = time_range.drop(time_range[time_range.month != 8]) +# elif x == 'Sep': +# timeranges['Sep_exp'] = time_range.drop(time_range[time_range.month != 9]) +# elif x == 'Oct': +# timeranges['Oct_exp'] = time_range.drop(time_range[time_range.month != 10]) +# elif x == 'Nov': +# timeranges['Nov_exp'] = time_range.drop(time_range[time_range.month != 11]) +# elif x == 'Dec': +# timeranges['Dec_exp'] = time_range.drop(time_range[time_range.month != 12]) +# elif x == 'Daylight' or 'Night': # or ('Daylight' and 'Night') +# ## Pip install sunriset module for calculate local sunrise and sunset times +# # !pip install sunriset + +# timezones = {'wa':'../../gdata1/data/boundaries/GEODATA_COAST_100K/western_australia/cstwacd_r.shp', +# 'nt':'../../gdata1/data/boundaries/GEODATA_COAST_100K/northern_territory/cstntcd_r.shp', +# 'sa':'../../gdata1/data/boundaries/GEODATA_COAST_100K/south_australia/cstsacd_r.shp', +# 'qld':'../../gdata1/data/boundaries/GEODATA_COAST_100K/queensland/cstqldmd_r.shp', +# 'nsw':'../../gdata1/data/boundaries/GEODATA_COAST_100K/new_south_wales/cstnswcd_r.shp', +# 'vic':'../../gdata1/data/boundaries/GEODATA_COAST_100K/victoria/cstviccd_r.shp', +# 'tas':'../../gdata1/data/boundaries/GEODATA_COAST_100K/tasmania/csttascd_r.shp' +# } + +# ## Determine the timezone of the pixels +# ## Bring in the state polygons (note: native crs = epsg:4283) +# wa = gpd.read_file(timezones['wa']) +# nt = gpd.read_file(timezones['nt']) +# sa = gpd.read_file(timezones['sa']) +# qld = gpd.read_file(timezones['qld']) +# nsw = gpd.read_file(timezones['nsw']) +# vic = gpd.read_file(timezones['vic']) +# tas = gpd.read_file(timezones['tas']) + +# # Merge the polygons to create single state/territory boundaries +# wa = gpd.GeoSeries(unary_union(wa.geometry)) +# nt = gpd.GeoSeries(unary_union(nt.geometry)) +# sa = gpd.GeoSeries(unary_union(sa.geometry)) +# qld = gpd.GeoSeries(unary_union(qld.geometry)) +# nsw = gpd.GeoSeries(unary_union(nsw.geometry)) +# vic = gpd.GeoSeries(unary_union(vic.geometry)) +# tas = gpd.GeoSeries(unary_union(tas.geometry)) + +# ## Note: day and night times will be calculated once per area-of-interest(ds) +# ## for the median latitude and longitude position of the aoi +# tidepost_lat_3577 = dem.x.median(dim='x').values +# tidepost_lon_3577 = dem.y.median(dim='y').values + +# ## Translate the crs of the tidepost to determine (1) local timezone +# ## and (2) the local sunrise and sunset times + +# ## Set the Datacube native crs (GDA/Aus Albers (meters)) +# crs_3577 = CRS.from_epsg(3577) + +# ## (1) Create a transform to convert default epsg3577 coords to epsg4283 to compare +# ## against state/territory boundary polygons and assign a timezone + +# ## GDA94 CRS (degrees) +# crs_4283 = CRS.from_epsg(4283) +# ## Transfer coords from/to +# transformer_4283 = Transformer.from_crs(crs_3577, crs_4283) +# ## Translate tidepost coords +# tidepost_lat_4283, tidepost_lon_4283 = transformer_4283.transform(tidepost_lat_3577, +# tidepost_lon_3577) +# ## Coordinate point to test for timezone +# point_4283 = Point(tidepost_lon_4283, tidepost_lat_4283) + +# ## (2) Create a transform to convert default epsg3577 coords to epsg4326 for use in +# ## sunise/sunset library + +# ## World WGS84 (degrees) +# crs_4326 = CRS.from_epsg(4326) +# ## Transfer coords from/to +# transformer_4326 = Transformer.from_crs(crs_3577, crs_4326) +# ## Translate the tidepost coords +# tidepost_lat_4326, tidepost_lon_4326 = transformer_4326.transform(tidepost_lat_3577, +# tidepost_lon_3577) +# ## Coordinate point to locate the sunriset calculation +# point_4326 = Point(tidepost_lon_4326, tidepost_lat_4326) + +# ## Set the local timezone for the analysis area of interest +# if wa.contains(point_4283)[0] == True: +# timezone = 'Australia/West' +# local_tz = 8 + +# elif nt.contains(point_4283)[0] == True: +# timezone = 'Australia/North' +# local_tz = 9.5 + +# elif sa.contains(point_4283)[0] == True: +# timezone = 'Australia/South' +# local_tz = 9.5 + +# elif qld.contains(point_4283)[0] == True: +# timezone = 'Australia/Queensland' +# local_tz = 10 + +# elif nsw.contains(point_4283)[0] == True: +# timezone = 'Australia/NSW' +# local_tz = 10 + +# elif vic.contains(point_4283)[0] == True: +# timezone = 'Australia/Victoria' +# local_tz = 10 + +# elif tas.contains(point_4283)[0] == True: +# timezone = 'Australia/Tasmania' +# local_tz = 10 + +# ## Calculate the local sunrise and sunset times +# # Place start and end dates in correct format +# start=round_date_strings(start_date, round_type="start") +# end=round_date_strings(end_date, round_type="end") +# startdate = datetime.date(pd.to_datetime(start).year, +# pd.to_datetime(start).month, +# pd.to_datetime(start).day) + +# # Make 'all_timerange' time-zone aware +# localtides = time_range.tz_localize(tz=pytz.UTC).tz_convert(timezone) + +# # Replace the UTC datetimes from all_timerange with local times +# modelledtides = pd.DataFrame(index = localtides) + +# # Return the difference in years for the time-period. +# # Round up to ensure all modelledtide datetimes are captured in the solar model +# diff = pd.to_datetime(end) - pd.to_datetime(start) +# diff = int(ceil(diff.days/365)) + +# ## Model sunrise and sunset +# sun_df = sunriset.to_pandas(startdate, tidepost_lat_4326, tidepost_lon_4326, local_tz, diff) + +# ## Set the index as a datetimeindex to match the modelledtide df +# sun_df = sun_df.set_index(pd.DatetimeIndex(sun_df.index)) + +# ## Append the date to each Sunrise and Sunset time +# sun_df['Sunrise dt'] = sun_df.index + sun_df['Sunrise'] +# sun_df['Sunset dt'] = sun_df.index + (sun_df['Sunset']) + +# ## Create new dataframes where daytime and nightime datetimes are recorded, then merged +# ## on a new `Sunlight` column +# daytime=pd.DataFrame(data = 'Sunrise', index=sun_df['Sunrise dt'], columns=['Sunlight']) +# nighttime=pd.DataFrame(data = 'Sunset', index=sun_df['Sunset dt'], columns=['Sunlight']) +# DayNight = pd.concat([daytime, nighttime], join='outer') +# DayNight.sort_index(inplace=True) +# DayNight.index.rename('Datetime', inplace=True) + +# ## Create an xarray object from the merged day/night dataframe +# day_night = xr.Dataset.from_dataframe(DayNight) + +# ## Remove local timezone timestamp column in modelledtides dataframe. Xarray doesn't handle +# ## timezone aware datetimeindexes 'from_dataframe' very well. +# modelledtides.index = modelledtides.index.tz_localize(tz=None) + +# ## Create an xr Dataset from the modelledtides pd.dataframe +# mt = modelledtides.to_xarray() + +# ## Filter the modelledtides (mt) by the daytime, nighttime datetimes from the sunriset module +# ## Modelled tides are designated as either day or night by propogation of the last valid index +# ## value forward +# Solar=day_night.sel(Datetime=mt.index, method='ffill') + +# ## Assign the day and night tideheight datasets +# SolarDayTides = mt.where(Solar.Sunlight=='Sunrise', drop=True) +# SolarNightTides = mt.where(Solar.Sunlight=='Sunset', drop=True) + +# ## Extract DatetimeIndexes to use in exposure calculations +# all_timerange_day = pd.DatetimeIndex(SolarDayTides.index) +# all_timerange_night = pd.DatetimeIndex(SolarNightTides.index) + +# if x == 'Daylight': +# timeranges['Day_exp'] = all_timerange_day +# if x == 'Night': +# timeranges['Night_exp'] = all_timerange_night + +# elif x in spatial_filters: + +# # #Run a full tidal model for each pixel +# # ModelledTides = pixel_tides( +# # dem,#ds, +# # times=time_range, +# # model=tide_model, +# # directory = tide_model_dir) +# # ## stack the y and x dimensions +# # stacked_everything = ModelledTides[0].stack(z=['y','x']).groupby('z') +# # # # Extract the modelling freq units +# # # freq_unit = modelled_freq.split()[0][-1] +# # # freq_value = modelled_freq.split()[0][:-1] +# # # # Extract the number of modelled timesteps per 14 days (half lunar cycle) +# # # mod_timesteps = np.timedelta64(14,'D') / np.timedelta64(freq_value,freq_unit) +# # ## Identify kwargs for peak detection algorithm + +# # # for x in mod_timesteps: +# # # order=(int(x/2)) +# # order=(int(mod_timesteps[0]/2)) + +# # ## Temp: for tide-regime testing +# # filt_dt['modelledtides'] = ModelledTides + +# ## Calculate the spring highest and spring lowest tides per 14 day half lunar cycle +# if x == 'Spring_high': + +# print ('Calculating Spring_high') + +# ## apply the peak detection routine +# stacked_everything_high = stacked_everything.apply(lambda x: xr.DataArray(argrelmax(x.values, order=order)[0])) +# ## Unstack +# springhighs_all = stacked_everything_high.unstack('z') +# ##Reorder the y axis. Uncertain why it gets reversed during the stack/unstack. +# springhighs_all = springhighs_all.reindex(y=springhighs_all.y[::-1]) +# ## Rename the time axis +# springhighs_all = springhighs_all.rename({'dim_0':'time'}) +# ## Convert to dataset +# springhighs_all = springhighs_all.to_dataset(name = 'time') +# ## Reorder the dims +# springhighs_all = springhighs_all[['time','y','x']] +# ## Select dates associated with detected peaks +# springhighs_all = ModelledTides[0].to_dataset().isel(time=springhighs_all.time) +# ## Extract the peak height dates +# # time_range = test_mt[springhighs].time.values + +# ## Temp: for tide-regime testing +# filt_dt['springhighs_all']=springhighs_all.tide_m + +# tide_cq = springhighs_all.tide_m.quantile(q=calculate_quantiles,dim='time') +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['springhigh_exp'] = idxmin * 100 + + +# ## Calculate the spring highest and spring lowest tides per 14 day half lunar cycle +# if x == 'Spring_low': +# print ('Calculating Spring_low') + +# ## apply the peak detection routine +# stacked_everything_low = stacked_everything.apply(lambda x: xr.DataArray(argrelmin(x.values, order=order)[0])) +# ## Unstack +# springlows_all = stacked_everything_low.unstack('z') +# ##Reorder the y axis. Uncertain why it gets reversed during the stack/unstack. +# springlows_all = springlows_all.reindex(y=springlows_all.y[::-1]) +# ## Rename the time axis +# springlows_all = springlows_all.rename({'dim_0':'time'}) +# ## Convert to dataset +# springlows_all = springlows_all.to_dataset(name = 'time') +# ## Reorder the dims +# springlows_all = springlows_all[['time','y','x']] +# ## Select dates associated with detected peaks +# springlows_all = ModelledTides[0].to_dataset().isel(time=springlows_all.time) +# ## Extract the peak height dates +# # time_range = test_mt[springlows_all].time.values + +# ## Temp: for tide-regime testing +# filt_dt['springlows_all'] = springlows_all.tide_m + +# tide_cq = springlows_all.tide_m.quantile(q=calculate_quantiles,dim='time') +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['springlow_exp'] = idxmin * 100 + +# if x == 'Neap_high': +# print ('Calculating Neap_high') +# ## Calculate the number of spring high tides to support calculation of neap highs +# ## apply the peak detection routine +# stacked_everything_high = stacked_everything.apply(lambda x: xr.DataArray(argrelmax(x.values, order=order)[0])) +# ## Unstack +# springhighs_all = stacked_everything_high.unstack('z') + +# ## apply the peak detection routine to calculate all the high tide maxima +# Max_testarray = stacked_everything.apply(lambda x: xr.DataArray(argrelmax(x.values)[0])) +# ## extract the corresponding dates from the peaks +# Max_testarray = (Max_testarray.unstack('z')) +# Max_testarray = (Max_testarray.reindex(y=Max_testarray.y[::-1]) +# .rename({'dim_0':'time'}) +# .to_dataset(name = 'time') +# [['time','y','x']] +# ) +# ## extract all hightide peaks +# Max_testarray = ModelledTides[0].to_dataset().isel(time=Max_testarray.time) + +# ## repeat the peak detection to identify neap high tides (minima in the high tide maxima) +# stacked_everything2 = Max_testarray.tide_m.stack(z=['y','x']).groupby('z') +# ## extract neap high tides based on 14 day half lunar cycle - determined as the fraction of all high tide points +# ## relative to the number of spring high tide values +# order_nh = int(ceil((len(Max_testarray.time)/(len(springhighs_all))/2))) +# ## apply the peak detection routine to calculate all the neap high tide minima within the high tide peaks +# neaphighs_all = stacked_everything2.apply(lambda x: xr.DataArray(argrelmin(x.values, order=order_nh)[0])) +# ## unstack and format as above +# neaphighs_all = neaphighs_all.unstack('z') +# neaphighs_all = ( +# neaphighs_all +# .reindex(y=neaphighs_all.y[::-1]) +# .rename({'dim_0':'time'}) +# .to_dataset(name = 'time') +# [['time','y','x']] +# ) +# ## extract neap high tides +# neaphighs_all = Max_testarray.isel(time=neaphighs_all.time) + +# ## Temp: for tide-regime testing +# filt_dt['neaphighs_all'] = neaphighs_all.tide_m + +# tide_cq = neaphighs_all.tide_m.quantile(q=calculate_quantiles,dim='time') +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['neaphigh_exp'] = idxmin * 100 + +# if x == 'Neap_low': +# print ('Calculating Neap_low') +# ## Calculate the number of spring low tides to support calculation of neap low tides +# ## apply the peak detection routine +# stacked_everything_low = stacked_everything.apply(lambda x: xr.DataArray(argrelmin(x.values, order=order)[0])) +# ## Unstack +# springlows_all = stacked_everything_low.unstack('z') + +# ## apply the peak detection routine to calculate all the low tide maxima +# Min_testarray = stacked_everything.apply(lambda x: xr.DataArray(argrelmin(x.values)[0])) +# ## extract the corresponding dates from the peaks +# Min_testarray = (Min_testarray.unstack('z')) +# Min_testarray = (Min_testarray.reindex(y=Min_testarray.y[::-1]) +# .rename({'dim_0':'time'}) +# .to_dataset(name = 'time') +# [['time','y','x']] +# ) +# ## extract all lowtide peaks +# Min_testarray = ModelledTides[0].to_dataset().isel(time=Min_testarray.time) + +# ## repeat the peak detection to identify neap low tides (maxima in the low tide maxima) +# stacked_everything2 = Min_testarray.tide_m.stack(z=['y','x']).groupby('z') +# ## extract neap high tides based on 14 day half lunar cycle - determined as the fraction of all high tide points +# ## relative to the number of spring high tide values +# order_nl = int(ceil((len(Min_testarray.time)/(len(springlows_all))/2))) +# ## apply the peak detection routine to calculate all the neap high tide minima within the high tide peaks +# neaplows_all = stacked_everything2.apply(lambda x: xr.DataArray(argrelmax(x.values, order=order_nl)[0])) +# ## unstack and format as above +# neaplows_all = neaplows_all.unstack('z') +# neaplows_all = ( +# neaplows_all +# .reindex(y=neaplows_all.y[::-1]) +# .rename({'dim_0':'time'}) +# .to_dataset(name = 'time') +# [['time','y','x']] +# ) +# ## extract neap high tides +# neaplows_all = Min_testarray.isel(time=neaplows_all.time) + +# ## Temp: for tide-regime testing +# filt_dt['neaplows_all']=neaplows_all.tide_m + +# tide_cq = neaplows_all.tide_m.quantile(q=calculate_quantiles,dim='time') +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['neaplow_exp'] = idxmin * 100 + + +# if x == 'Hightide': +# print ('Calculating Hightide') +# def lowesthightides(x): +# ''' +# x is a grouping of x and y pixels from the peaks_array (labelled as 'z') +# ''' + +# ## apply the peak detection routine to calculate all the high tide maxima +# high_peaks = np.array(argrelmax(x.values)[0]) + +# ## extract all hightide peaks +# Max_testarray = x.isel(time=high_peaks) + +# ## Identify all lower hightide peaks +# lowhigh_peaks = np.array(argrelmin(Max_testarray.values)[0]) + +# ## Interpolate the lower hightide curve +# neap_high_linear = interp1d( +# ## low high peaks as a subset of all high tide peaks +# high_peaks[lowhigh_peaks], +# ## Corresponding tide heights +# Max_testarray.isel(time=lowhigh_peaks).squeeze(['z']).values, +# kind='linear', +# fill_value='extrapolate' +# ) +# ## Create an array to interpolate into sans datetimes +# count = np.arange(0,len(x),1) +# neap_high_testline = neap_high_linear(count) + +# # # Extract hightides as all tides higher than/equal to the extrapolated lowest high tide line +# hightide = x.squeeze(['z']).where(x.squeeze(['z']) >= neap_high_testline, drop=True) + +# return hightide + +# ## Vectorise the hightide calculation +# lowhighs_all = stacked_everything.apply(lambda x: xr.DataArray(lowesthightides(x))) + +# # ## Unstack and re-format the array +# lowhighs_all = lowhighs_all.unstack('z') +# lowhighs_all_unstacked = ( +# lowhighs_all +# .reindex(y=lowhighs_all.y[::-1]) +# .to_dataset() +# [['tide_m','time','y','x']] +# ) + +# ## Temp: for tide-regime testing +# filt_dt['hightides'] = lowhighs_all_unstacked.tide_m + +# tide_cq = lowhighs_all_unstacked.tide_m.quantile(q=calculate_quantiles,dim='time') + +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['hightide_exp'] = idxmin * 100 + +# # return hightide_exposure + +# if x == 'Lowtide': +# print ('Calculating Lowtide') +# def highestlowtides(x): +# ''' +# x is a grouping of x and y pixels from the peaks_array (labelled as 'z') +# ''' + +# ## apply the peak detection routine to calculate all the high tide maxima +# low_peaks = np.array(argrelmin(x.values)[0]) + +# ## extract all hightide peaks +# Min_testarray = x.isel(time=low_peaks) + +# ## Identify all lower hightide peaks +# highlow_peaks = np.array(argrelmax(Min_testarray.values)[0]) + +# ## Interpolate the lower hightide curve +# neap_low_linear = interp1d( +# ## low high peaks as a subset of all high tide peaks +# low_peaks[highlow_peaks], +# ## Corresponding tide heights +# Min_testarray.isel(time=highlow_peaks).squeeze(['z']).values, +# # stacked_everything33, +# # stacked_everything333.isel(y=0,x=0), # z=0 in stacked arrays? +# # stacked_everything333,#.isel(z=x), # z=0 in stacked arrays? +# # stacked_everything333.squeeze(['z']).values, +# bounds_error=False, +# kind='linear', +# fill_value='extrapolate' +# ) +# ## Create an array to interpolate into sans datetimes +# count = np.arange(0,len(x),1) +# neap_low_testline = neap_low_linear(count) + +# # # Extract hightides as all tides higher than/equal to the extrapolated lowest high tide line +# lowtide = x.squeeze(['z']).where(x.squeeze(['z']) <= neap_low_testline, drop=True) + +# return lowtide + +# ## Vectorise the hightide calculation +# highlows_all = stacked_everything.apply(lambda x: xr.DataArray(highestlowtides(x))) + +# # ## Unstack and re-format the array +# highlows_all = highlows_all.unstack('z') +# highlows_all_unstacked = ( +# highlows_all +# .reindex(y=highlows_all.y[::-1]) +# .to_dataset() +# [['tide_m','time','y','x']] +# ) + +# ## Temp: for tide-regime testing +# filt_dt['lowtides'] = highlows_all_unstacked.tide_m + +# tide_cq = highlows_all_unstacked.tide_m.quantile(q=calculate_quantiles,dim='time') + +# tide_cq_dict[str(x)]=tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['lowtide_exp'] = idxmin * 100 + +# for x in timeranges: + +# # Run the pixel_tides function with the calculate_quantiles option. +# # For each pixel, an array of tideheights is returned, corresponding +# # to the percentiles from `calculate_quantiles` of the timerange-tide model that +# # each tideheight appears in the model. +# # tide_cq, _ = pixel_tides( +# # dem, +# # resample=True, +# # calculate_quantiles=calculate_quantiles, +# # times=timeranges[str(x)], +# # model=tide_model, +# # directory=tide_model_dir, +# # cutoff=np.inf, +# # ) + +# if (tide_model[0] == "ensemble") or (tide_model == "ensemble"): +# # Use ensemble model combining multiple input ocean tide models +# tide_cq, _ = pixel_tides_ensemble( +# dem, +# # resample=True, +# calculate_quantiles=calculate_quantiles, +# # times=timeranges[str(x)], +# times=time_range, +# # times=time_range, +# directory=tide_model_dir, +# cutoff=np.inf, +# ancillary_points="data/raw/corr_points.geojson", +# ) + +# else: +# # Use single input ocean tide model +# tide_cq, _ = pixel_tides( +# dem, +# resample=True, +# calculate_quantiles=calculate_quantiles, +# # times=timeranges[str(x)], +# times=time_range, +# model=tide_model, +# directory=tide_model_dir, +# cutoff=np.inf,) + +# tide_cq_dict[str(x)] = tide_cq + +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure[str(x)] = idxmin * 100 + +# # return exposure, tide_cq + +# if filters is None: + +# # Run the pixel_tides function with the calculate_quantiles option. +# # For each pixel, an array of tideheights is returned, corresponding +# # to the percentiles from `calculate_quantiles` of the timerange-tide model that +# # each tideheight appears in the model. +# # tide_cq, _ = pixel_tides( +# # dem, +# # resample=True, +# # calculate_quantiles=calculate_quantiles, +# # times=time_range, +# # model=tide_model, +# # directory=tide_model_dir, +# # cutoff=np.inf, +# # ) + +# if (tide_model[0] == "ensemble") or (tide_model == "ensemble"): +# # Use ensemble model combining multiple input ocean tide models +# tide_cq, _ = pixel_tides_ensemble( +# dem, +# # resample=True, +# calculate_quantiles=calculate_quantiles, +# # times=timeranges[str(x)], +# times=time_range, +# # times=time_range, +# directory=tide_model_dir, +# cutoff=np.inf, +# ancillary_points="data/raw/corr_points.geojson", +# ) + +# else: +# # Use single input ocean tide model +# tide_cq, _ = pixel_tides( +# dem, +# resample=True, +# calculate_quantiles=calculate_quantiles, +# # times=timeranges[str(x)], +# times=time_range, +# model=tide_model, +# directory=tide_model_dir, +# cutoff=np.inf, +# ) + +# tide_cq_dict['all_epoch']=tide_cq +# # Calculate the tide-height difference between the elevation value and +# # each percentile value per pixel +# diff = abs(tide_cq - dem) + +# # Take the percentile of the smallest tide-height difference as the +# # exposure % per pixel +# idxmin = diff.idxmin(dim="quantile") + +# # Convert to percentage +# exposure['all_epoch_exp'] = idxmin * 100 + +# return exposure, tide_cq_dict, filt_dt #filt_dt is temp and only works with spatial customs +# # return exposure + +# # # Run the pixel_tides function with the calculate_quantiles option. +# # # For each pixel, an array of tideheights is returned, corresponding +# # # to the percentiles from `calculate_quantiles` of the timerange-tide model that +# # # each tideheight appears in the model. +# # tide_cq, _ = pixel_tides( +# # dem, +# # resample=True, +# # calculate_quantiles=calculate_quantiles, +# # times=time_range, +# # model=tide_model, +# # directory=tide_model_dir, +# # cutoff=np.inf, +# # ) + +# # # Calculate the tide-height difference between the elevation value and +# # # each percentile value per pixel +# # diff = abs(tide_cq - dem) + +# # # Take the percentile of the smallest tide-height difference as the +# # # exposure % per pixel +# # idxmin = diff.idxmin(dim="quantile") + +# # # Convert to percentage +# # exposure = idxmin * 100 + +# # return exposure, tide_cq, time_range + + + diff --git a/intertidal/tide_modelling.py b/intertidal/tide_modelling.py new file mode 100644 index 0000000..fd4476f --- /dev/null +++ b/intertidal/tide_modelling.py @@ -0,0 +1,127 @@ +import xarray as xr +import geopandas as gpd + +from dea_tools.coastal import pixel_tides, _pixel_tides_resample +from dea_tools.spatial import interpolate_2d + +def pixel_tides_ensemble( + satellite_ds, + directory, + ancillary_points, + top_n=3, + models=None, + interp_method="nearest", + times=None, + calculate_quantiles=None, + cutoff=None, + **pixel_tides_kwargs, + +): + """ + Generate an ensemble tide model, choosing the best three tide models + for any coastal location using ancillary point data (e.g. altimetry + observations or NDWI correlations along the coastline). + + This function generates an ensemble of tidal height predictions for + each pixel in a satellite dataset. Firstly, tides from multiple tide + models are modelled into a low resolution grid using `pixel_tides`. + Ancillary point data is then loaded and interpolated to the same + grid to serve as weightings. These weightings are used to retain + only the top three tidal models, and remaining top models are + combined into a single ensemble output for each time/x/y. + The resulting ensemble tides are then resampled and reprojected to + match the high-resolution satellite data. + + Parameters: + ----------- + satellite_ds : xarray.Dataset + Three-dimensional dataset containing satellite-derived + information (x by y by time). + directory : str + Directory containing tidal model data; see `pixel_tides`. + ancillary_points : str + Path to a file containing point correlations for different tidal + models. + times : tuple or None, optional + Tuple containing start and end time of time range to be used for + tide model in the format of "YYYY-MM-DD". + top_n : integer, optional + The number of top models to use in the ensemble calculation. + Default is 3, which will calculate a median of the top 3 models. + models : list or None, optional + An optional list of tide models to use for the ensemble model. + Default is None, which will use "FES2014", "FES2012", "EOT20", + "TPXO8-atlas-v1", "TPXO9-atlas-v5", "HAMTIDE11", "GOT4.10". + interp_method : str, optional + Interpolation method used to interpolate correlations onto the + low-resolution tide grid. Default is "nearest". + + Returns: + -------- + tides_highres : xarray.Dataset + High-resolution ensemble tidal heights dataset. + weights_ds : xarray.Dataset + Dataset containing weights for each tidal model used in the ensemble. + """ + # Use default models if none provided + if models is None: + models = [ + "FES2014", + "FES2012", + "TPXO8-atlas-v1", + "TPXO9-atlas-v5", + "EOT20", + "HAMTIDE11", + "GOT4.10", + ] + + tide_lowres = pixel_tides( + satellite_ds, + resample=False, + calculate_quantiles=calculate_quantiles, + times=times, + model=models, + directory=directory, + cutoff=cutoff, + ) + + # Load ancillary points from file, reproject to match satellite + # data, and drop empty points + print("Generating ensemble tide model from point inputs") + corr_gdf = ( + gpd.read_file(ancillary_points)[models + ["geometry"]] + .to_crs(satellite_ds.odc.crs) + .dropna() + ) + + # Loop through each model, interpolating correlations into + # low-res tide grid + out_list = [] + + for model in models: + out = interpolate_2d( + tide_lowres, + x_coords=corr_gdf.geometry.x, + y_coords=corr_gdf.geometry.y, + z_coords=corr_gdf[model], + method=interp_method, + ).expand_dims({"tide_model": [model]}) + + out_list.append(out) + + # Combine along tide model dimension into a single xarray.Dataset + weights_ds = xr.concat(out_list, dim="tide_model") + + # Mask out all but the top N models, then take median of remaining + # to produce a single ensemble output for each time/x/y + tide_lowres_ensemble = tide_lowres.where( + (weights_ds.rank(dim="tide_model") > (len(models) - top_n)) + ).median("tide_model") + + # Resample/reproject ensemble tides to match high-res satellite data + tides_highres, tides_lowres = _pixel_tides_resample( + tides_lowres=tide_lowres_ensemble, + ds=satellite_ds, + ) + + return tides_highres, weights_ds diff --git a/notebooks/Intertidal_workflow.ipynb b/notebooks/Intertidal_workflow.ipynb index 90926a5..92bbaf2 100644 --- a/notebooks/Intertidal_workflow.ipynb +++ b/notebooks/Intertidal_workflow.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "ccccdf10-6065-4f91-8725-d3233ebbe6d4", + "id": "44932e9f", "metadata": { "tags": [] }, @@ -15,17 +15,27 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "3cdd49c0-fef3-4b10-9d45-d28c41755e12", - "metadata": {}, - "outputs": [], + "execution_count": 1, + "id": "b18166da", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/jovyan/dea_intertidal/dea-intertidal\n" + ] + } + ], "source": [ - "cd .." + "%cd /home/jovyan/dea_intertidal/dea-intertidal/" ] }, { "cell_type": "markdown", - "id": "9e0e6a00-0c55-4ec3-881f-4cdd32899772", + "id": "51d593a1", "metadata": {}, "source": [ "Install additional packages directly from the requirements file" @@ -33,17 +43,39 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "924876a7-a415-4d65-81c4-5e5cd7b7b53d", - "metadata": {}, - "outputs": [], + "execution_count": 2, + "id": "a9e5e54a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], "source": [ "pip install -r requirements.in --quiet" ] }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e8d039a7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# !pip install sunriset" + ] + }, { "cell_type": "markdown", - "id": "4dac1027-e128-4b7d-a5af-b7b360673e53", + "id": "cff69d46", "metadata": {}, "source": [ "### Load packages" @@ -51,9 +83,11 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "325d183a-2ca2-42c8-9061-02849068c92e", - "metadata": {}, + "execution_count": 4, + "id": "06f536eb", + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "%load_ext autoreload\n", @@ -62,29 +96,49 @@ "import os\n", "import pandas as pd\n", "import numpy as np\n", + "import xarray as xr\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", "from ipyleaflet import basemaps, basemap_to_tiles\n", "\n", "import datacube\n", + "from odc.algo import mask_cleanup\n", "from odc.geo.geom import Geometry\n", "from odc.ui import select_on_a_map\n", "\n", + "import rioxarray\n", + "import odc.geo.xr\n", + "\n", "from intertidal.utils import (\n", " round_date_strings,\n", " export_intertidal_rasters,\n", " intertidal_hillshade,\n", - ")\n", - "from intertidal.elevation import load_data, load_topobathy, elevation\n", + " )\n", + "from intertidal.tide_modelling import pixel_tides_ensemble\n", + "from intertidal.elevation import load_data, load_topobathy, elevation#, pixel_tides_ensemble\n", "from intertidal.extents import extents\n", "from intertidal.exposure import exposure\n", "from intertidal.tidal_bias_offset import bias_offset, tidal_offset_tidelines\n", "from dea_tools.dask import create_local_dask_cluster" ] }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cb8285ef-bada-4834-83c2-96ed185bcf5a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "\n", + "from intertidal.tide_modelling import pixel_tides_ensemble\n" + ] + }, { "cell_type": "markdown", - "id": "bd675e30-92c7-494f-9f16-2ea0ae1de32f", + "id": "34f2a478", "metadata": { "tags": [] }, @@ -94,7 +148,7 @@ }, { "cell_type": "markdown", - "id": "3fbdf7a0-4daa-49c1-a3f7-3e0bd0e38560", + "id": "a83b7160", "metadata": { "tags": [] }, @@ -104,8 +158,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "ad578cb2-0465-4613-9e0a-14764abd17f6", + "execution_count": 6, + "id": "f00107c2", "metadata": { "tags": [] }, @@ -138,7 +192,7 @@ }, { "cell_type": "markdown", - "id": "9545c2f6-d1d7-4848-a17f-54eb484279bb", + "id": "65b1e0b2", "metadata": {}, "source": [ "#### Set study area\n", @@ -148,19 +202,21 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "92f3b5ca-b73a-47b2-b27c-ff63a4ace984", - "metadata": {}, + "execution_count": 7, + "id": "a54c5653", + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "# Set study area (e.g. tile ID in form 'x143y87')\n", - "study_area = \"x133y40\"\n", - "geom = None # Use GridSpec to load study area, not a custom geom" + "# # Set study area (e.g. tile ID in form 'x143y87')\n", + "# study_area = \"x139y96\"\n", + "# geom = None # Use GridSpec to load study area, not a custom geom" ] }, { "cell_type": "markdown", - "id": "16e7ab04-cfc9-49e4-b75c-b39439143c20", + "id": "cbba20c2", "metadata": { "tags": [] }, @@ -170,8 +226,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "33bd708e-3c17-49c5-aa96-403ac50df896", + "execution_count": 8, + "id": "e35efaea", "metadata": { "tags": [] }, @@ -190,7 +246,7 @@ }, { "cell_type": "markdown", - "id": "05c2043a-47dc-4b2b-a481-ef1bbf01ae80", + "id": "cc7c76f2", "metadata": {}, "source": [ "##### Option 3: load study area using interactive map" @@ -198,13 +254,43 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "b7084b95-0d68-4bf5-81fc-1f26809cdc38", - "metadata": {}, - "outputs": [], + "execution_count": 9, + "id": "9895b5c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b8c0966385fb4402b8069aa81760107b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map(center=[-26, 135], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_t…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": [ + "" + ], + "text/plain": [ + "Geometry(POLYGON ((147.971251 -19.925788, 147.971251 -19.914854, 148.004188 -19.914854, 148.004188 -19.925788, 147.971251 -19.925788)), EPSG:4326)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Set study area name for outputs\n", - "study_area = \"testing\"\n", + "study_area = \"test\"\n", "\n", "# Plot interactive map to select area\n", "basemap = basemap_to_tiles(basemaps.Esri.WorldImagery)\n", @@ -214,7 +300,7 @@ }, { "cell_type": "markdown", - "id": "ef305306-b424-4d6b-9183-ca480012f2d7", + "id": "3a77a221", "metadata": {}, "source": [ "## Intertidal workflow\n", @@ -224,10 +310,728 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "21ed7ba2-3efe-4065-a495-7b80f5256e94", - "metadata": {}, - "outputs": [], + "execution_count": 10, + "id": "7b142abf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/env/lib/python3.10/site-packages/datacube/drivers/driver_cache.py:54: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html\n", + " from pkg_resources import iter_entry_points\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-677ef90d-9972-11ee-8532-6644e48f7052

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", + " Dashboard: /user/claire.phillips@ga.gov.au/proxy/8787/status\n", + "
\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

LocalCluster

\n", + "

cf78f641

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + "
\n", + " Dashboard: /user/claire.phillips@ga.gov.au/proxy/8787/status\n", + " \n", + " Workers: 1\n", + "
\n", + " Total threads: 31\n", + " \n", + " Total memory: 237.21 GiB\n", + "
Status: runningUsing processes: True
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + " \n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-fc59355a-22c1-45fe-aa3c-84a92c99a640

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://127.0.0.1:40645\n", + " \n", + " Workers: 1\n", + "
\n", + " Dashboard: /user/claire.phillips@ga.gov.au/proxy/8787/status\n", + " \n", + " Total threads: 31\n", + "
\n", + " Started: Just now\n", + " \n", + " Total memory: 237.21 GiB\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 0

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:38105\n", + " \n", + " Total threads: 31\n", + "
\n", + " Dashboard: /user/claire.phillips@ga.gov.au/proxy/40105/status\n", + " \n", + " Memory: 237.21 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:33807\n", + "
\n", + " Local directory: /tmp/dask-worker-space/worker-1z5uw4u1\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dimensions: (time: 433, y: 164, x: 356)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2019-01-01T00:22:14.283000 ... 2021-12...\n", + " * y (y) float64 -2.239e+06 -2.239e+06 ... -2.24e+06 -2.24e+06\n", + " * x (x) float64 1.66e+06 1.66e+06 1.66e+06 ... 1.664e+06 1.664e+06\n", + " spatial_ref int32 3577\n", + "Data variables:\n", + " ndwi (time, y, x) float32 dask.array\n", + "Attributes:\n", + " crs: EPSG:3577\n", + " grid_mapping: spatial_ref\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/env/lib/python3.10/site-packages/datacube/drivers/driver_cache.py:54: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html\n", + " from pkg_resources import iter_entry_points\n", + "/env/lib/python3.10/site-packages/rasterio/warp.py:344: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n", + " _reproject(\n", + "/env/lib/python3.10/site-packages/rasterio/warp.py:344: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n", + " _reproject(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 9.04 s, sys: 838 ms, total: 9.88 s\n", + "Wall time: 1min 18s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:      (time: 433, y: 164, x: 356)\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[ns] 2019-01-01T00:22:14.283000 ... 2021-12...\n",
+       "  * y            (y) float64 -2.239e+06 -2.239e+06 ... -2.24e+06 -2.24e+06\n",
+       "  * x            (x) float64 1.66e+06 1.66e+06 1.66e+06 ... 1.664e+06 1.664e+06\n",
+       "    spatial_ref  int32 3577\n",
+       "Data variables:\n",
+       "    ndwi         (time, y, x) float32 nan nan nan nan nan ... nan nan nan nan\n",
+       "Attributes:\n",
+       "    crs:           EPSG:3577\n",
+       "    grid_mapping:  spatial_ref
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 433, y: 164, x: 356)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2019-01-01T00:22:14.283000 ... 2021-12...\n", + " * y (y) float64 -2.239e+06 -2.239e+06 ... -2.24e+06 -2.24e+06\n", + " * x (x) float64 1.66e+06 1.66e+06 1.66e+06 ... 1.664e+06 1.664e+06\n", + " spatial_ref int32 3577\n", + "Data variables:\n", + " ndwi (time, y, x) float32 nan nan nan nan nan ... nan nan nan nan\n", + "Attributes:\n", + " crs: EPSG:3577\n", + " grid_mapping: spatial_ref" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "%%time\n", "\n", @@ -259,7 +1063,7 @@ }, { "cell_type": "markdown", - "id": "6a0020d0-69be-4522-93d5-dede79e7591f", + "id": "ad0ab3e3", "metadata": {}, "source": [ "### Load optional topobathy mask\n", @@ -269,8 +1073,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "bafd49db-52c8-4796-a2f5-da568da9b86d", + "execution_count": 11, + "id": "2adcc77b", "metadata": { "tags": [] }, @@ -284,7 +1088,7 @@ }, { "cell_type": "markdown", - "id": "5b00d348-b532-4ccf-a0e1-51c5c189e735", + "id": "fd2c1630", "metadata": {}, "source": [ "### Intertidal elevation\n", @@ -293,12 +1097,98 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "d7f1d42b-343c-47b4-bdd9-465efd407280", + "execution_count": 16, + "id": "45de9453-5ca0-4879-85fd-09864229bbb2", "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-12-13 04:50:42 INFO Modelling tide heights for each pixel\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating reduced resolution 5000 x 5000 metre tide modelling array\n", + "Modelling tides using FES2014, FES2012, TPXO8-atlas-v1, TPXO9-atlas-v5, EOT20, HAMTIDE11, GOT4.10 in parallel\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 35/35 [00:17<00:00, 1.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returning low resolution tide array\n", + "Generating ensemble tide model from point inputs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-12-13 04:51:04 INFO Masking nodata and adding tide heights to satellite data array\n", + "2023-12-13 04:51:04 INFO Flattening satellite data array and filtering to intertidal candidate pixels\n", + "2023-12-13 04:51:04 INFO Applying valid data mask to constrain study area\n", + "2023-12-13 04:51:06 INFO Running per-pixel rolling median\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reducing analysed pixels from 58384 to 13555 (23.22%)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb3713871a794847aa8dec80fa15539b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/114 [00:00 1\u001b[0m (hightideline, lowtideline, tidelines_gdf) \u001b[38;5;241m=\u001b[39m \u001b[43mtidal_offset_tidelines\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mextents\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mds\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mextents\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43moffset_hightide\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mds\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moa_offset_hightide\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43moffset_lowtide\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mds\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moa_offset_lowtide\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mdistance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m250\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/dea_intertidal/dea-intertidal/intertidal/tidal_bias_offset.py:143\u001b[0m, in \u001b[0;36mtidal_offset_tidelines\u001b[0;34m(extents, offset_hightide, offset_lowtide, distance)\u001b[0m\n\u001b[1;32m 140\u001b[0m tidelines_gdf \u001b[38;5;241m=\u001b[39m subpixel_contours(da\u001b[38;5;241m=\u001b[39mextents, z_values\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m1.5\u001b[39m, \u001b[38;5;241m0.5\u001b[39m])\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# Translate the high/Low tidelines into point data at regular intervals\u001b[39;00m\n\u001b[0;32m--> 143\u001b[0m lowtideline \u001b[38;5;241m=\u001b[39m \u001b[43mpoints_on_line\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtidelines_gdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdistance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdistance\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 144\u001b[0m hightideline \u001b[38;5;241m=\u001b[39m points_on_line(tidelines_gdf, \u001b[38;5;241m1\u001b[39m, distance\u001b[38;5;241m=\u001b[39mdistance)\n\u001b[1;32m 146\u001b[0m \u001b[38;5;66;03m# Extract the point coordinates into xarray for the hightideline dataset\u001b[39;00m\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/dea_tools/spatial.py:72\u001b[0m, in \u001b[0;36mpoints_on_line\u001b[0;34m(gdf, index, distance)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;124;03mGenerates evenly-spaced point features along a specific line feature\u001b[39;00m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;124;03min a `geopandas.GeoDataFrame`.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;124;03m `distance` along the selected line.\u001b[39;00m\n\u001b[1;32m 69\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;66;03m# Select individual line to generate points along\u001b[39;00m\n\u001b[0;32m---> 72\u001b[0m line_feature \u001b[38;5;241m=\u001b[39m \u001b[43mgdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[38;5;241m.\u001b[39mgeometry\n\u001b[1;32m 74\u001b[0m \u001b[38;5;66;03m# If multiple features are returned, take unary union\u001b[39;00m\n\u001b[1;32m 75\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m line_feature\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexing.py:1073\u001b[0m, in \u001b[0;36m_LocationIndexer.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 1070\u001b[0m axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxis \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 1072\u001b[0m maybe_callable \u001b[38;5;241m=\u001b[39m com\u001b[38;5;241m.\u001b[39mapply_if_callable(key, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj)\n\u001b[0;32m-> 1073\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_axis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmaybe_callable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexing.py:1301\u001b[0m, in \u001b[0;36m_LocIndexer._getitem_axis\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1298\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(key, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mndim\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m key\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 1299\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCannot index with multidimensional key\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1301\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_getitem_iterable\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1303\u001b[0m \u001b[38;5;66;03m# nested tuple slicing\u001b[39;00m\n\u001b[1;32m 1304\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_nested_tuple(key, labels):\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexing.py:1239\u001b[0m, in \u001b[0;36m_LocIndexer._getitem_iterable\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1236\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_key(key, axis)\n\u001b[1;32m 1238\u001b[0m \u001b[38;5;66;03m# A collection of keys\u001b[39;00m\n\u001b[0;32m-> 1239\u001b[0m keyarr, indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_listlike_indexer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1240\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_reindex_with_indexers(\n\u001b[1;32m 1241\u001b[0m {axis: [keyarr, indexer]}, copy\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, allow_dups\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 1242\u001b[0m )\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexing.py:1432\u001b[0m, in \u001b[0;36m_LocIndexer._get_listlike_indexer\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m 1429\u001b[0m ax \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_get_axis(axis)\n\u001b[1;32m 1430\u001b[0m axis_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobj\u001b[38;5;241m.\u001b[39m_get_axis_name(axis)\n\u001b[0;32m-> 1432\u001b[0m keyarr, indexer \u001b[38;5;241m=\u001b[39m \u001b[43max\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_indexer_strict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1434\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m keyarr, indexer\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexes/base.py:6070\u001b[0m, in \u001b[0;36mIndex._get_indexer_strict\u001b[0;34m(self, key, axis_name)\u001b[0m\n\u001b[1;32m 6067\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 6068\u001b[0m keyarr, indexer, new_indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reindex_non_unique(keyarr)\n\u001b[0;32m-> 6070\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_raise_if_missing\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkeyarr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis_name\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6072\u001b[0m keyarr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtake(indexer)\n\u001b[1;32m 6073\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(key, Index):\n\u001b[1;32m 6074\u001b[0m \u001b[38;5;66;03m# GH 42790 - Preserve name from an Index\u001b[39;00m\n", + "File \u001b[0;32m/env/lib/python3.10/site-packages/pandas/core/indexes/base.py:6130\u001b[0m, in \u001b[0;36mIndex._raise_if_missing\u001b[0;34m(self, key, indexer, axis_name)\u001b[0m\n\u001b[1;32m 6128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_interval_msg:\n\u001b[1;32m 6129\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(key)\n\u001b[0;32m-> 6130\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNone of [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m] are in the [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00maxis_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 6132\u001b[0m not_found \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(ensure_index(key)[missing_mask\u001b[38;5;241m.\u001b[39mnonzero()[\u001b[38;5;241m0\u001b[39m]]\u001b[38;5;241m.\u001b[39munique())\n\u001b[1;32m 6133\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnot_found\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not in index\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mKeyError\u001b[0m: \"None of [Int64Index([0], dtype='int64')] are in the [index]\"" + ] + } + ], "source": [ "(hightideline, lowtideline, tidelines_gdf) = tidal_offset_tidelines(\n", " extents=ds.extents,\n", @@ -411,7 +1397,7 @@ }, { "cell_type": "markdown", - "id": "12d5f458-6e32-4bd6-ab25-4417dfaa5edb", + "id": "2986d91d", "metadata": {}, "source": [ "## Plot all layers" @@ -419,21 +1405,573 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "98d4c60e-1378-424b-ab13-7d3dc1d4ca09", + "execution_count": 45, + "id": "b80d35e1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                (y: 164, x: 356)\n",
+       "Coordinates:\n",
+       "  * y                      (y) float64 -2.239e+06 -2.239e+06 ... -2.24e+06\n",
+       "  * x                      (x) float64 1.66e+06 1.66e+06 ... 1.664e+06 1.664e+06\n",
+       "    spatial_ref            int32 3577\n",
+       "    band                   int64 1\n",
+       "Data variables:\n",
+       "    elevation              (y, x) float64 nan nan nan nan ... nan nan nan nan\n",
+       "    elevation_uncertainty  (y, x) float64 nan nan nan nan ... nan nan nan nan\n",
+       "    extents                (y, x) float64 3.0 3.0 3.0 3.0 ... 3.0 3.0 3.0 3.0\n",
+       "    exposure               (y, x) float64 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_lat                 (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_hat                 (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_lot                 (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_hot                 (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_spread              (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_offset_lowtide      (y, x) float32 nan nan nan nan ... nan nan nan nan\n",
+       "    oa_offset_hightide     (y, x) float32 nan nan nan nan ... nan nan nan nan
" + ], + "text/plain": [ + "\n", + "Dimensions: (y: 164, x: 356)\n", + "Coordinates:\n", + " * y (y) float64 -2.239e+06 -2.239e+06 ... -2.24e+06\n", + " * x (x) float64 1.66e+06 1.66e+06 ... 1.664e+06 1.664e+06\n", + " spatial_ref int32 3577\n", + " band int64 1\n", + "Data variables:\n", + " elevation (y, x) float64 nan nan nan nan ... nan nan nan nan\n", + " elevation_uncertainty (y, x) float64 nan nan nan nan ... nan nan nan nan\n", + " extents (y, x) float64 3.0 3.0 3.0 3.0 ... 3.0 3.0 3.0 3.0\n", + " exposure (y, x) float64 nan nan nan nan ... nan nan nan nan\n", + " oa_lat (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_hat (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_lot (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_hot (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_spread (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_offset_lowtide (y, x) float32 nan nan nan nan ... nan nan nan nan\n", + " oa_offset_hightide (y, x) float32 nan nan nan nan ... nan nan nan nan" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Inspect contents of ds before plotting\n", + "# ds\n", + "\n", + "\n", + "ds.load()\n", "ds" ] }, { "cell_type": "code", - "execution_count": null, - "id": "21dd40e3-1e1e-4f07-a606-76eaf463114c", + "execution_count": 46, + "id": "0b8f96f8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'lowtideline' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[46], line 114\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;66;03m# Plot the high and low tidelines with respective offset\u001b[39;00m\n\u001b[1;32m 113\u001b[0m ax_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mL\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mset_title(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLowtide line and lowtide offset\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 114\u001b[0m \u001b[43mlowtideline\u001b[49m\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 115\u001b[0m column\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moffset_lowtide\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 116\u001b[0m legend\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 117\u001b[0m vmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m 118\u001b[0m vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m40\u001b[39m,\n\u001b[1;32m 119\u001b[0m cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmagma\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 120\u001b[0m ax\u001b[38;5;241m=\u001b[39max_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mL\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 121\u001b[0m zorder\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[1;32m 122\u001b[0m )\n\u001b[1;32m 123\u001b[0m tidelines_gdf\u001b[38;5;241m.\u001b[39mloc[[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgeometry\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mplot(ax\u001b[38;5;241m=\u001b[39max_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mL\u001b[39m\u001b[38;5;124m\"\u001b[39m], zorder\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 124\u001b[0m ax_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mL\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mset_xlim(left\u001b[38;5;241m=\u001b[39mds\u001b[38;5;241m.\u001b[39melevation\u001b[38;5;241m.\u001b[39mx\u001b[38;5;241m.\u001b[39mmin(), right\u001b[38;5;241m=\u001b[39mds\u001b[38;5;241m.\u001b[39melevation\u001b[38;5;241m.\u001b[39mx\u001b[38;5;241m.\u001b[39mmax())\n", + "\u001b[0;31mNameError\u001b[0m: name 'lowtideline' is not defined" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/env/lib/python3.10/site-packages/matplotlib/cm.py:478: RuntimeWarning: invalid value encountered in cast\n", + " xx = (xx * 255).astype(np.uint8)\n", + "/env/lib/python3.10/site-packages/IPython/core/pylabtools.py:152: UserWarning: Tight layout not applied. tight_layout cannot make axes width small enough to accommodate all axes decorations\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = plt.figure(figsize=(16, 18), tight_layout=True)\n", "ax_dict = fig.subplot_mosaic(\n", @@ -479,9 +2017,9 @@ ")\n", "ax_dict[\"C\"].set_title(\"Exposure\")\n", "\n", - "# Plot the always/sometimes/never wet extents\n", + "# Plot Extents\n", "ds[\"extents\"].astype(np.int16).plot.imshow(ax=ax_dict[\"D\"])\n", - "ax_dict[\"D\"].set_title(\"Wet, Dry and Intertidal extent\")\n", + "ax_dict[\"D\"].set_title(\"Extents\")\n", "\n", "# Plot the observation spread\n", "ds[\"oa_spread\"].plot.imshow(\n", @@ -586,7 +2124,7 @@ }, { "cell_type": "markdown", - "id": "b55e9c43-a6e7-49fc-a4de-e97558f5393c", + "id": "e91f81d3", "metadata": { "tags": [] }, @@ -597,7 +2135,19 @@ { "cell_type": "code", "execution_count": null, - "id": "301b8d2e-9507-4e69-b107-3b372e953b1f", + "id": "1e0658e8-72f4-4f85-a824-8f3701dd082e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# study_area = 'Perth_5pxlandusebuffer'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57c54b70", "metadata": {}, "outputs": [], "source": [ @@ -609,7 +2159,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c3fcf901-846e-4cc0-96ee-912937110c29", + "id": "1a027ec4", "metadata": {}, "outputs": [], "source": [ @@ -625,7 +2175,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dba82a22-55b7-430a-89fb-8115cc29dad5", + "id": "4cc049a7", "metadata": {}, "outputs": [], "source": [ @@ -636,7 +2186,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b0b149db-805c-4f97-b463-9d223581271a", + "id": "5a9a7fb9", "metadata": {}, "outputs": [], "source": [ @@ -654,7 +2204,7 @@ }, { "cell_type": "markdown", - "id": "2ec2d9b5-7855-412a-807f-b1238d61be23", + "id": "f84ff11f", "metadata": { "tags": [] }, @@ -665,7 +2215,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1183efdd-5183-4d40-86c4-0b5b9f48fe11", + "id": "a59ba636", "metadata": {}, "outputs": [], "source": [ @@ -689,7 +2239,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.10.13" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/requirements.in b/requirements.in index 625c1c6..3eef6e2 100644 --- a/requirements.in +++ b/requirements.in @@ -4,7 +4,7 @@ bokeh==3.2.2 # temporary fix for Dask issue botocore click==8.1.3 datacube[s3,performance]==1.8.13 -dea-tools==0.3.1.dev1 +dea-tools==0.3.1.dev5 geopandas==0.13.2 matplotlib==3.7.1 numpy==1.24.3 @@ -18,6 +18,7 @@ rasterio==1.3.4 scikit_image==0.19.3 scikit_learn==1.2.2 scipy==1.10.1 +sunriset==1.0 Shapely==2.0.1 tqdm==4.65.0 xarray==2023.1.0 \ No newline at end of file