Combinaison de données satellitaires et de modélisation des marées à l’aide d’OTPS#

Mots-clés données utilisées; landsat 5, données utilisées; landsat 7, données utilisées; landsat 8, marée; modélisation, intertidal, dask

Aperçu#

Les marées océaniques sont des phénomènes de montée et de descente périodiques de l’océan provoqués par l’attraction gravitationnelle de la lune et du soleil et par la rotation de la terre. Les marées dans les zones côtières peuvent grandement influencer la façon dont ces environnements apparaissent sur les images satellite, car les niveaux d’eau varient jusqu’à 12 mètres. Pour pouvoir étudier les processus environnementaux le long du littoral africain, il est essentiel d’obtenir des données sur les conditions de marée au moment exact où chaque image satellite a été acquise.

Description#

Ce carnet démontre comment combiner l’imagerie par télédétection avec des informations sur les marées océaniques en utilisant des fonctions du paquet eo-tides Python, nous permettant d’analyser l’imagerie satellite par hauteurs de marée et stade de marée (par exemple basse, haute, jusant, flux). Ces fonctions utilisent les modèles mondiaux de marées océaniques pour calculer la hauteur (par rapport au niveau moyen de la mer) et le stade de la marée au moment exact où chaque image satellite a été acquise.

Le cahier montre comment :

  1. Charger un exemple de série chronologique de données satellitaires

  2. Utilisez la fonction tag_tide du paquet eo-tides pour modéliser les hauteurs de marée pour chaque observation satellite

  3. Utiliser les données sur la hauteur des marées pour produire des composites médians de la côte à marée basse et haute

  4. Calculer les données de phase de marée montante ou descendante pour déterminer si les niveaux d’eau montaient ou descendaient dans chaque observation satellite

  5. Utilisez la fonction « tidal_stats » pour évaluer les éventuels biais dans les conditions de marée observées par un satellite

Commencer#

Pour exécuter cette analyse, exécutez toutes les cellules du bloc-notes, en commençant par la cellule « Charger les packages ».

Charger des paquets#

Exigence d’installation#

Ce carnet nécessite la version 2.2.9 de pyTMD.

Veuillez l’installer avant d’exécuter les imports :

```bash pip install pyTMD==2.2.9

[1]:

# pip install pyTMD==2.2.9

[2]:

import datacube
import xarray as xr
import geopandas as gpd
from odc.geo.geom import Geometry

from deafrica_tools.plotting import rgb, display_map
from deafrica_tools.datahandling import load_ard, mostcommon_crs
from eo_tides import tag_tides
from eo_tides.stats import tide_stats
from deafrica_tools.dask import create_local_dask_cluster
from deafrica_tools.areaofinterest import define_area

Configurer un cluster Dask#

Dask peut être utilisé pour mieux gérer l’utilisation de la mémoire et effectuer l’analyse en parallèle. Pour une introduction à l’utilisation de Dask avec Digital Earth Africa, consultez le Dask notebook.

Remarque : nous vous recommandons d’ouvrir la fenêtre de traitement Dask pour afficher les différents calculs en cours d’exécution ; pour ce faire, consultez la section Tableau de bord Dask en Afrique de l’Ouest du Dask notebook.

Pour utiliser Dask, configurez le cluster de calcul local à l’aide de la cellule ci-dessous.

[3]:

create_local_dask_cluster()

Client

Client-de8ffd76-3319-11f1-86e0-66c27c7d89dc

Connection method: Cluster object Cluster type: distributed.LocalCluster
Dashboard: /user/mpho.sadiki@digitalearthafrica.org/proxy/36481/status

Cluster Info

Se connecter au datacube#

[4]:

dc = datacube.Datacube(app="Tidal_modelling")

Configurer la requête de données#

Nous commençons par configurer une requête pour définir la zone, la période et les autres paramètres requis pour le chargement des données. Dans cet exemple, nous allons charger 30 ans de données Landsat 5, 7 et 8 pour l’estuaire de la rivière Geba dans le sud de la Guinée-Bissau. Nous chargeons les bandes « rouge », « verte », « bleue » afin de pouvoir représenter les données sous forme d’images en couleurs réelles.

Remarque : le paramètre « dask_chunks » nous permet d’utiliser Dask pour charger les données de manière différée plutôt que de les charger directement en mémoire <https://examples.dask.org/xarray.html>, car la méthode de chargement standard peut prendre beaucoup de temps et nécessiter beaucoup de mémoire. Le chargement différé peut être une approche très utile lorsque vous devez charger de grandes quantités de données sans faire planter votre analyse. Dans les applications côtières, il nous permet de charger (en utilisant soit « .compute() » soit en traçant nos données) uniquement un petit sous-ensemble d’observations de l’ensemble de notre série chronologique (par exemple, uniquement les observations de marée basse ou haute) sans avoir à charger l’ensemble des données en mémoire au préalable, ce qui peut réduire considérablement les temps de traitement.

Définir l’emplacement#

Pour définir la zone d’intérêt, deux méthodes sont disponibles :

  1. En spécifiant la latitude, la longitude et la zone tampon. Cette méthode nécessite que vous saisissiez la latitude centrale, la longitude centrale et la valeur de la zone tampon en degrés carrés autour du point central que vous souhaitez analyser. Par exemple, « lat = 10,338 », « lon = -1,055 » et « buffer = 0,1 » sélectionneront une zone avec un rayon de 0,1 degré carré autour du point avec les coordonnées (10,338, -1,055).

  2. By uploading a polygon as a GeoJSON or Esri Shapefile. If you choose this option, you will need to upload the geojson or ESRI shapefile into the Sandbox using Upload Files button 6f7540d95d124cc2bbf3a81f8e46b810 in the top left corner of the Jupyter Notebook interface. ESRI shapefiles must be uploaded with all the related files (.cpg, .dbf, .shp, .shx). Once uploaded, you can use the shapefile or geojson to define the area of interest. Remember to update the code to call the file you have uploaded.

Pour utiliser l’une de ces méthodes, vous pouvez décommenter la ligne de code concernée et commenter l’autre. Pour commenter une ligne, ajoutez le symbole "#" avant le code que vous souhaitez commenter. Par défaut, la première option qui définit l’emplacement à l’aide de la latitude, de la longitude et du tampon est utilisée.

[5]:

# Define the location
# Method 1: Specify the latitude, longitude, and buffer
aoi = define_area(lat=11.689, lon=-15.674, buffer=0.15)

# Method 2: Use a polygon as a GeoJSON or Esri Shapefile.
# aoi = define_area(vector_path='aoi.shp')

# Create a geopolygon and geodataframe of the area of interest
geopolygon = Geometry(aoi["features"][0]["geometry"], crs="epsg:4326")
geopolygon_gdf = gpd.GeoDataFrame(geometry=[geopolygon], crs=geopolygon.crs)

# Get the latitude and longitude range of the geopolygon
lat_range = (geopolygon_gdf.total_bounds[1], geopolygon_gdf.total_bounds[3])
lon_range = (geopolygon_gdf.total_bounds[0], geopolygon_gdf.total_bounds[2])

# Create a reusable query
query = {
    "x": lon_range,
    "y": lat_range,
    "time": ("1988-01-01", "2018-12-31"),
    "measurements": ["red", "green", "blue"],
    "resolution": (-30, 30),
    "dask_chunks": {},
}

Nous pouvons prévisualiser la zone pour laquelle nous allons charger des données :

[6]:

display_map(x=query["x"], y=query["y"])

[6]:
Make this Notebook Trusted to load map: File -> Trust Notebook

Charger des séries chronologiques de satellites#

Pour obtenir des données satellite à analyser, nous utilisons la fonction « load_ard » pour importer une série chronologique d’observations Landsat 5, 7 et 8 sous forme de « xarray.Dataset ». Les données d’entrée n’ont pas besoin de provenir de Landsat : toute imagerie de télédétection avec horodatage et coordonnées spatiales fournit suffisamment de données pour exécuter le modèle de marée.

[7]:

# Identify the most common projection system in the input query
output_crs = mostcommon_crs(dc=dc, product="ls8_sr", query=query)

# Load available data from all three Landsat satellites
ds = load_ard(
    dc=dc,
    products=["ls5_sr", "ls7_sr", "ls8_sr"],
    output_crs=output_crs,
    align=(15, 15),
    ls7_slc_off=False,
    group_by="solar_day",
    **query
)

# Print output data
print(ds)

Using pixel quality parameters for USGS Collection 2
Finding datasets
    ls5_sr
    ls7_sr
    Ignoring SLC-off observations for ls7
    ls8_sr
Applying pixel quality/cloud mask
Re-scaling Landsat C2 data
Returning 227 time steps as a dask array
<xarray.Dataset> Size: 3GB
Dimensions:      (time: 227, y: 1109, x: 1093)
Coordinates:
  * time         (time) datetime64[ns] 2kB 1988-07-17T10:52:47.658038 ... 201...
  * y            (y) float64 9kB 1.309e+06 1.309e+06 ... 1.276e+06 1.276e+06
  * x            (x) float64 9kB 4.102e+05 4.102e+05 ... 4.429e+05 4.429e+05
    spatial_ref  int32 4B 32628
Data variables:
    red          (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
    green        (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
    blue         (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
Attributes:
    crs:           EPSG:32628
    grid_mapping:  spatial_ref

/opt/venv/lib/python3.12/site-packages/deafrica_tools/datahandling.py:565: FutureWarning: In a future version of xarray the default value for compat will change from compat='no_conflicts' to compat='override'. This is likely to lead to different results when combining overlapping variables with the same name. To opt in to new defaults and get rid of these warnings now use `set_options(use_new_combine_kwarg_defaults=True) or set compat explicitly.
  ds = xr.merge([ds_data, ds_masks])

Modéliser les hauteurs de marée pour chaque observation#

Nous pouvons maintenant passer notre jeu de données satellite ds à la fonction tag_tides pour modéliser une marée pour chaque pas de temps dans notre jeu de données.

La fonction tag_tides utilise la date et l’heure d’acquisition et le centroïde géographique de chaque observation satellite comme entrées pour le modèle de marée sélectionné (EOT20 par défaut). Elle renvoie un xarray.DataArray appelé tide_height, avec une marée modélisée pour chaque pas de temps dans notre jeu de données satellite :

[8]:

# # Model tide heights
model_dir = "/var/share/tide_models"

tides_da = tag_tides(
    data=ds,
    directory=model_dir,
)

# Print modelled tides
tides_da

Setting tide modelling location from dataset centroid: -15.67, 11.69
Modelling tides with EOT20

[8]:

<xarray.DataArray 'tide_height' (time: 227)> Size: 908B
array([ 0.8592769 , -0.18536592, -0.24930622, -0.21912642,  1.3536943 ,
        1.5856296 , -0.36671248, -1.162862  , -0.84991807,  0.78121537,
        1.2990576 ,  0.5875723 , -0.5906921 , -1.198272  , -0.87473166,
       -0.23873524, -0.46583444,  0.8389599 ,  1.2147173 , -0.90109295,
        2.2094488 , -0.10366018, -0.7232631 ,  0.93119794,  0.09051751,
       -1.5260075 ,  0.4858677 , -1.0699933 , -0.9408271 , -0.7329113 ,
        2.3638723 ,  1.5525019 ,  0.1859477 , -1.1284522 ,  0.02373447,
        1.9752105 ,  1.4451119 ,  0.08928777, -1.1222141 , -0.9019982 ,
       -1.0450093 ,  0.79601216,  2.3718722 ,  1.4501921 , -0.06832927,
       -1.0044726 , -1.0839821 ,  0.17514926,  1.235538  ,  1.4246706 ,
        0.99165756, -1.0692114 , -0.80042666,  0.8843542 ,  1.5233799 ,
        2.4851034 ,  0.8361768 , -0.30938658, -1.2930602 , -1.010503  ,
       -0.8662913 ,  1.3671592 ,  1.7509861 , -0.29216802, -0.8316837 ,
        0.6845504 ,  0.9089041 ,  1.5951457 ,  2.4264863 ,  1.636322  ,
        1.1844784 ,  0.6951644 , -0.5465059 , -1.1753923 , -1.0261688 ,
       -1.1895244 , -0.65899706,  0.6656056 ,  1.5154617 ,  1.7234896 ,
        1.0035887 , -0.26266134, -0.8812882 , -1.418292  , -0.77705395,
        0.09498855,  0.34845093,  1.3668454 ,  2.103673  ,  1.6849209 ,
        1.6869351 , -0.23761284, -0.5975377 , -0.8819262 , -1.2235104 ,
       -0.49499667,  0.59162694, -0.21275352,  0.59459233,  1.6347721 ,
...
       -0.9089948 , -0.27688542, -0.162714  ,  1.245498  ,  1.928993  ,
        1.8759419 ,  2.3370724 ,  1.5809414 ,  0.30614835, -0.11390533,
       -0.92469454, -1.5192188 , -0.9430964 , -0.40575445, -0.19064783,
        1.0995171 ,  1.6986959 ,  1.7050391 ,  2.1494768 ,  1.3949219 ,
        0.20653185, -0.14812092, -1.0164082 , -1.4779083 , -0.7888232 ,
       -0.31432354,  1.4256083 ,  1.9217592 ,  2.3725417 ,  1.3677355 ,
        0.12567818, -0.16532955, -1.123294  , -1.5323508 , -0.8538998 ,
       -0.4728178 ,  0.01170299,  1.2474009 ,  1.7048676 ,  1.7812264 ,
        2.1977248 ,  1.234935  ,  0.09342687, -0.1761156 , -1.1653123 ,
       -1.4053906 , -0.6627003 ,  0.30462867,  1.5867989 ,  1.9666264 ,
        2.3179724 ,  1.1569254 , -0.02334541, -0.24811259, -1.2985601 ,
       -1.4740304 , -0.7577282 , -0.5203916 ,  0.24021955,  1.3851444 ,
        1.6893141 ,  1.8696413 ,  2.1551821 ,  1.0754136 ,  0.01313501,
       -0.23448984, -1.2910479 , -1.2690802 , -0.53377897,  0.5520059 ,
        1.7250115 ,  1.8446099 ,  2.008283  ,  2.1571045 ,  0.95168877,
       -0.13945593, -0.35539186, -1.4434679 , -1.3494217 , -0.66648966,
       -0.5192263 ,  0.45858455,  1.50598   ,  1.6530383 ,  1.971703  ,
        2.0207052 ,  0.925047  , -1.3809084 , -1.0875833 , -0.41610128,
        0.7656607 ,  1.8128856 ,  1.733615  ,  2.0340157 ,  1.9105709 ,
        0.7570475 , -0.20097291], dtype=float32)
Coordinates:
  * time        (time) datetime64[ns] 2kB 1988-07-17T10:52:47.658038 ... 2018...
    tide_model  <U5 20B 'EOT20'

Nous pouvons facilement combiner ces marées modélisées avec nos données satellites originales pour une analyse plus approfondie. Le code ci-dessous ajoute nos marées modélisées comme une nouvelle variable tide_height sous Variables de données.

[9]:

ds["tide_height"] = tides_da
ds

[9]:

<xarray.Dataset> Size: 3GB
Dimensions:      (time: 227, y: 1109, x: 1093)
Coordinates:
  * time         (time) datetime64[ns] 2kB 1988-07-17T10:52:47.658038 ... 201...
  * y            (y) float64 9kB 1.309e+06 1.309e+06 ... 1.276e+06 1.276e+06
  * x            (x) float64 9kB 4.102e+05 4.102e+05 ... 4.429e+05 4.429e+05
    spatial_ref  int32 4B 32628
    tide_model   <U5 20B 'EOT20'
Data variables:
    red          (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
    green        (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
    blue         (time, y, x) float32 1GB dask.array<chunksize=(1, 1109, 1093), meta=np.ndarray>
    tide_height  (time) float32 908B 0.8593 -0.1854 -0.2493 ... 0.757 -0.201
Attributes:
    crs:           EPSG:32628
    grid_mapping:  spatial_ref

Nous pouvons facilement représenter graphiquement cette nouvelle variable pour inspecter la plage de hauteurs de marée observées par les satellites dans notre série temporelle. Dans cet exemple, nos hauteurs de marée observées varient d’environ -1,0 à 1,0 m par rapport au niveau moyen de la mer :

[10]:

ds.tide_height.plot()

[10]:

[<matplotlib.lines.Line2D at 0x7f026370dd60>]
../../../_images/sandbox_notebooks_Frequently_used_code_Tidal_modelling_22_1.png

Exemple d’analyse de la hauteur des marées#

Pour démontrer comment les images marquées par les marées peuvent être utilisées pour produire des composites d’images de marée haute et basse, nous pouvons calculer les 5 % les plus bas et les 5 % les plus hauts des hauteurs de marée, et les utiliser pour filtrer nos observations. Nous pouvons ensuite combiner et tracer ces observations filtrées pour visualiser à quoi ressemble le paysage à marée basse et à marée haute :

Remarque : nous vous recommandons d’ouvrir la fenêtre de traitement Dask pour afficher les différents calculs en cours d’exécution ; pour ce faire, consultez la section Tableau de bord Dask en Afrique de l’Ouest du Dask notebook.

Remarque : une approche alternative pour combiner des observations dans un composite peut être obtenue en utilisant un géomédian, ce qui garantit que les relations entre les bandes restent cohérentes. Des informations supplémentaires sont fournies dans le bloc-notes « Génération de composites géomédians <Generating_geomedian_composites.ipynb> ».

[11]:

# Calculate the lowest and highest 5% of tides
lowest_5, highest_5 = ds.tide_height.quantile([0.05, 0.95]).values

# Filter our data to low and high tide observations
filtered_low = ds.where(ds.tide_height <= lowest_5, drop=True)
filtered_high = ds.where(ds.tide_height >= highest_5, drop=True)

# Take the simple median of each set of low and high tide observations to
# produce a composite (alternatively, observations could be combined
# using a geomedian to keep band relationships consistent)
median_low = filtered_low.median(dim="time", keep_attrs=True)
median_high = filtered_high.median(dim="time", keep_attrs=True)

# Combine low and high tide medians into a single dataset and give
# each layer a meaningful name
ds_highlow = xr.concat([median_low, median_high], dim="tide_height")
ds_highlow["tide_height"] = ["Low tide", "High tide"]

# Plot low and high tide medians side-by-side
rgb(ds_highlow, col="tide_height")
../../../_images/sandbox_notebooks_Frequently_used_code_Tidal_modelling_24_0.png

Modélisation des phases de marée montante et descendante#

La fonction tag_tides nous permet également de déterminer si chaque observation satellite a été prise pendant que la marée montait/entrait (flux) ou descendait/sortait (jusant) en définissant return_phases=True. Cela est réalisé en comparant les hauteurs de marée 15 minutes avant et après l’observation satellite observée.

Les données de flux et de reflux peuvent fournir des informations contextuelles précieuses pour l’interprétation des images satellite, en particulier dans les environnements de vasières ou de forêts de mangroves où l’eau peut rester dans le paysage pendant un temps considérable après le pic de marée.

[12]:

tides_da = tag_tides(
    data=ds,
    directory=model_dir,
    return_phases=True,
)

# Print modelled tides
tides_da

Setting tide modelling location from dataset centroid: -15.67, 11.69
Modelling tides with EOT20
Modelling tides with EOT20

[12]:

<xarray.Dataset> Size: 5kB
Dimensions:      (time: 227)
Coordinates:
  * time         (time) datetime64[ns] 2kB 1988-07-17T10:52:47.658038 ... 201...
    tide_model   <U5 20B 'EOT20'
Data variables:
    tide_height  (time) float32 908B 0.8593 -0.1854 -0.2493 ... 0.757 -0.201
    tide_phase   (time) object 2kB 'high-flow' 'low-flow' ... 'low-flow'

Nous disposons désormais de données nous indiquant à la fois la hauteur de la marée et la phase de marée (« flux » ou « reflux ») pour chaque image satellite :

[13]:

tides_da[["time", "tide_height", "tide_phase"]].to_dataframe()

[13]:
tide_height tide_phase tide_model
time
1988-07-17 10:52:47.658038 0.859277 high-flow EOT20
1988-08-18 10:52:49.179013 -0.185366 low-flow EOT20
1988-10-05 10:52:43.680006 -0.249306 low-ebb EOT20
1988-10-21 10:52:37.662000 -0.219126 low-ebb EOT20
1988-12-08 10:52:31.815006 1.353694 high-ebb EOT20
... ... ... ...
2018-10-24 11:21:58.388427 1.733615 high-ebb EOT20
2018-11-09 11:22:01.151598 2.034016 high-flow EOT20
2018-11-25 11:22:00.936674 1.910571 high-flow EOT20
2018-12-11 11:21:57.773631 0.757047 high-flow EOT20
2018-12-27 11:21:57.806437 -0.200973 low-flow EOT20

227 rows × 3 columns

Nous pourrions par exemple utiliser ces données pour filtrer nos observations afin de ne conserver que les observations en phase de reflux :

[14]:

tides_da.where(tides_da.tide_phase.str.contains("ebb"), drop=True)

[14]:

<xarray.Dataset> Size: 2kB
Dimensions:      (time: 108)
Coordinates:
  * time         (time) datetime64[ns] 864B 1988-10-05T10:52:43.680006 ... 20...
    tide_model   <U5 20B 'EOT20'
Data variables:
    tide_height  (time) float32 432B -0.2493 -0.2191 1.354 ... 1.813 1.734
    tide_phase   (time) object 864B 'low-ebb' 'low-ebb' ... 'high-ebb'

Évaluation des hauteurs de marée observées par rapport à toutes les hauteurs de marée modélisées#

Le comportement complexe des marées signifie qu’un capteur héliosynchrone comme Landsat « n’observe pas l’intégralité du cycle des marées à tous les endroits <https://www.sciencedirect.com/science/article/pii/S0272771418308783#sec3> ». Des biais dans la proportion de l’amplitude des marées observée par les satellites peuvent nous empêcher d’obtenir des données sur les zones du littoral exposées ou inondées aux extrémités de l’amplitude des marées. Cela peut risquer d’obtenir des informations trompeuses sur l’étendue réelle de la zone du littoral affectée par les marées et rendre difficile la comparaison équitable des images de marée haute ou basse dans différents endroits.

La fonction tide_stats peut aider à évaluer comment la gamme de marées observées par les satellites se compare à la gamme de marées complète. Elle fonctionne en utilisant le modèle de marée OTPS pour modéliser les hauteurs de marée à un intervalle régulier (toutes les deux heures par défaut) sur toute la période couverte par le jeu de données de séries temporelles satellites en entrée. Cela est ensuite comparé aux hauteurs de marée observées par le satellite et utilisé pour calculer une gamme de statistiques et un tracé qui résume les biais potentiels dans les données.

Remarque : pour une discussion plus détaillée de la question du biais de marée dans les observations par satellite héliosynchrones du littoral, reportez-vous à la section « Limitations et travaux futurs » dans Bishop-Taylor et al. 2018 <https://www.sciencedirect.com/science/article/pii/S0272771418308783#sec3>`__.

[15]:

out_stats = tide_stats(data=ds, directory=model_dir)

Using tide modelling location: -15.67, 11.69
Modelling tides with EOT20
Using tide modelling location: -15.67, 11.69
Modelling tides with EOT20


🌊 Modelled astronomical tide range: 5.13 m (-2.53 to 2.60 m).
🛰️ Observed tide range: 4.02 m (-1.53 to 2.49 m).

🟡 78% of the modelled astronomical tide range was observed at this location.
🟢 The highest 2% (0.12 m) of the tide range was never observed.
🟡 The lowest 19% (1.00 m) of the tide range was never observed.

🌊 Mean modelled astronomical tide height: 0.00 m.
🛰️ Mean observed tide height: 0.34 m.
⬆️ The mean observed tide height was 0.34 m higher than the mean modelled astronomical tide height.
../../../_images/sandbox_notebooks_Frequently_used_code_Tidal_modelling_32_1.png

La fonction tide_stats produit également un objet pandas.Series contenant un ensemble de statistiques qui comparent les gammes de marées observées par rapport aux gammes de marées modélisées complètes. Ces statistiques incluent :

  • mot : hauteur de marée moyenne observée par le satellite (mètres)

  • mat : hauteur de marée astronomique modélisée moyenne (mètres)

  • hot : hauteur de marée maximale observée par le satellite (mètres)

  • hat : hauteur de marée maximale de la gamme de marée astronomique modélisée (mètres)

  • lot : hauteur de marée minimale observée par le satellite (mètres)

  • lat : hauteur de marée minimale de la gamme de marée astronomique modélisée (mètres)

  • otr : gamme de marée observée par le satellite (mètres)

  • tr : gamme de marée astronomique modélisée (mètres)

  • spread : proportion de la gamme de marée modélisée complète observée par le satellite

  • offset_low : proportion des marées les plus basses jamais observées par le satellite

  • offset_high : proportion des marées les plus hautes jamais observées par le satellite

  • y : latitude utilisée pour modéliser les hauteurs de marée

  • x : longitude utilisée pour modéliser les hauteurs de marée

[16]:

print(out_stats)

mot             0.344
mat             0.000
hot             2.485
hat             2.603
lot            -1.532
lat            -2.529
otr             4.017
tr              5.131
spread          0.783
offset_low      0.194
offset_high     0.023
x             -15.674
y              11.689
dtype: float32

Informations Complémentaires#

Licence : Le code de ce carnet est sous licence Apache, version 2.0 <https://www.apache.org/licenses/LICENSE-2.0>. Les données de Digital Earth Africa sont sous licence Creative Commons par attribution 4.0 <https://creativecommons.org/licenses/by/4.0/>.

Contact : Si vous avez besoin d’aide, veuillez poster une question sur le canal Slack Open Data Cube <http://slack.opendatacube.org/>`__ ou sur le GIS Stack Exchange en utilisant la balise open-data-cube (vous pouvez consulter les questions posées précédemment ici). Si vous souhaitez signaler un problème avec ce bloc-notes, vous pouvez en déposer un sur Github.

Version de Datacube compatible :

[17]:

print(datacube.__version__)

1.9.13

Dernier test :

[18]:

from datetime import datetime

datetime.today().strftime("%Y-%m-%d")

[18]:

'2026-04-08'