Chargement des données depuis Digital Earth Africa
Produits utilisés : gm_s2_annual, wofs_ls_summary_annual
Prérequis : Les utilisateurs de ce bloc-notes doivent avoir une compréhension de base de :
Comment exécuter un Jupyter notebook
Inspection des produits et mesures disponibles en Afrique DE <02_Products_and_measurements.ipynb>`__
Mots-clés guide du débutant ; chargement des données, chargement des données ; guide du débutant, données utilisées ; géomédiane Landsat 8, données utilisées ; WOfS, méthodes de données ; rééchantillonnage méthodes de données ; reprojection, attributs de données ; système de référence de coordonnées
Aperçu
Le chargement de données à partir de l’instance Digital Earth Africa (DE Africa) du Open Data Cube nécessite la construction d’une requête de données qui spécifie le quoi, le où et le quand de la demande de données. Chaque requête renvoie un objet xarray multidimensionnel contenant le contenu de votre requête. Il est essentiel de comprendre les structures de données xarray car elles sont fondamentales pour la structure des données chargées à partir du datacube. Les manipulations, les transformations et la visualisation des objets xarray offrent aux utilisateurs de datacube la possibilité d’explorer et d’analyser les ensembles de données DE Africa, ainsi que de poser et de répondre à des questions scientifiques.
Description
Ce cahier présente comment charger des données à partir du cube de données Digital Earth Africa grâce à la construction d’une requête et à l’utilisation de la fonction « dc.load() ». Les sujets abordés incluent :
Chargement des données à l’aide de
dc.load()Interprétation de l’objet « xarray.Dataset » résultant
Inspection d’un « xarray.DataArray » individuel
Personnalisation des paramètres passés à la fonction « dc.load() »
Chargement de mesures spécifiques
Chargement de données pour les coordonnées dans un système de référence de coordonnées personnalisé (CRS)
Projection de données vers un nouveau SCR et une nouvelle résolution spatiale
Spécification d’une méthode de rééchantillonnage spatial spécifique
Chargement de données à l’aide d’une requête de dictionnaire réutilisable
Chargement des données correspondantes à partir de plusieurs produits à l’aide de « like »
Ajout d’une barre de progression au chargement des données
Commencer
Pour exécuter cette introduction au chargement de données depuis DE Africa, exécutez toutes les cellules du bloc-notes en commençant par la cellule « Charger les packages ». Pour obtenir de l’aide sur l’exécution des cellules du bloc-notes, reportez-vous au bloc-notes Jupyter Notebooks.
Charger des paquets
Nous devons d’abord charger le package « datacube ». Cela nous permettra d’interroger la base de données datacube et de charger des données. La fonction « with_ui_cbk » de « odc.ui » nous permettra d’afficher une barre de progression lors du chargement de grandes quantités de données.
[1]:
import datacube
from odc.ui import with_ui_cbk
Se connecter au datacube
Nous devons ensuite nous connecter à la base de données datacube. Nous pourrons alors utiliser l’objet datacube dc pour charger des données. Le paramètre app est un nom unique utilisé pour identifier le notebook qui n’a aucun effet sur l’analyse.
[2]:
dc = datacube.Datacube(app="03_Loading_data")
Chargement des données à l’aide de dc.load()
Le chargement des données à partir du datacube utilise la fonction dc.load().
La fonction nécessite les arguments minimum suivants :
product: Un produit spécifique à charger (pour réviser les produits DE Africa, voir le notebook Produits et mesures).« x » : définit la région spatiale dans la dimension x. Par défaut, les arguments x et y acceptent les requêtes dans un système de coordonnées géographiques WGS84, identifié par le code EPSG 4326.
« y » : définit la région spatiale dans la dimension y. Les dimensions « longitude »/« latitude » et « x »/« y » peuvent être utilisées de manière interchangeable.
time: définit l’étendue temporelle. La dimension temporelle peut être spécifiée à l’aide d’un tuple d’objets datetime ou de chaînes au format « AAAA », « AAAA-MM » ou « AAAA-MM-JJ ».
Un argument optionnel qui facilite l’utilisation et l’identification des mesures à charger est :
measurements:Cet argument est utilisé pour fournir une liste de noms de mesures à charger, comme indiqué dansdc.list_measurements(). Pour les ensembles de données satellites, les mesures contiennent des données pour chaque bande satellite individuelle (par exemple, proche infrarouge). Si elles ne sont pas fournies, toutes les mesures du produit seront renvoyées et elles porteront les noms par défaut des données satellites.
Exécutons une requête pour charger les données 2018 du produit géomédian annuel Sentinel 2 <https://explorer.digitalearth.africa/gm_s2_annual>`__ pour une partie du parc national de Nxai Pan au Botswana. Pour cet exemple, nous pouvons utiliser les paramètres suivants :
produit:gm_s2_annualx:(24,60, 24,80)y:(-20,05, -20,25)heure:("2018-01-01", "2018-12-31")mesures:['bleu', 'vert', 'rouge', 'nir', 'swir_1', 'swir_2', 'emad', 'bcmad', 'smad', 'red_edge_1']
Exécutez la cellule suivante pour charger tous les ensembles de données du produit « gm_s2_annual » qui correspondent à cette étendue spatiale et temporelle :
[3]:
ds = dc.load(product="gm_s2_annual",
x=(24.65, 24.75),
y=(-20.05, -20.15),
time=("2018-01-01", "2018-12-31"),
measurements=['blue', 'green', 'red', 'nir', 'swir_1', 'swir_2', 'emad', 'bcmad', 'smad', 'red_edge_1'])
print(ds)
<xarray.Dataset>
Dimensions: (time: 1, y: 1201, x: 966)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.519e+06 -2.519e+06
* x (x) float64 2.378e+06 2.378e+06 ... 2.388e+06 2.388e+06
spatial_ref int32 6933
Data variables:
blue (time, y, x) uint16 789 814 827 825 820 ... 765 707 650 647
green (time, y, x) uint16 1137 1162 1174 1177 ... 1294 1245 1207 1215
red (time, y, x) uint16 1419 1453 1479 1494 ... 1151 1063 993 1006
nir (time, y, x) uint16 2607 2631 2644 2677 ... 1840 1761 1693 1636
swir_1 (time, y, x) uint16 3350 3362 3392 3387 ... 750 657 544 403
swir_2 (time, y, x) uint16 2442 2453 2482 2467 ... 509 442 375 303
emad (time, y, x) float32 784.9 801.8 832.2 ... 1.629e+03 1.695e+03
bcmad (time, y, x) float32 0.0516 0.05199 0.05344 ... 0.2089 0.2288
smad (time, y, x) float32 0.001915 0.001836 ... 0.03017 0.04047
red_edge_1 (time, y, x) uint16 1824 1835 1867 1877 ... 1805 1782 1722 1679
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Interprétation du « xarray.Dataset » résultant
La variable « ds » a renvoyé un « xarray.Dataset » contenant toutes les données correspondant aux paramètres de requête spatiale et temporelle saisis dans « dc.load ».
Dimensions
Identifie le nombre de pas de temps renvoyés dans la recherche (
time: 1) ainsi que le nombre de pixels dans les directions « x » et « y » de la requête de données.
Coordonnées
« time » identifie la date attribuée à chaque pas de temps renvoyé.
« x » et « y » sont les coordonnées de chaque pixel dans les limites spatiales de votre requête.
Variables de données
Il s’agit des mesures disponibles pour le produit désigné. Pour chaque date (
time) renvoyée par la requête, la valeur mesurée à chaque pixel (y,x) est renvoyée sous forme de tableau pour chaque mesure. Chaque variable de données est elle-même un objetxarray.DataArray(voir ci-dessous).
Attributs
« crs » identifie le système de référence de coordonnées (CRS) des données chargées.
Inspection d’un « xarray.DataArray » individuel
Le « xarray.Dataset » que nous avons chargé ci-dessus est lui-même une collection d’objets « xarray.DataArray » individuels qui contiennent les données réelles pour chaque variable de données/mesure. Par exemple, toutes les mesures répertoriées sous Variables de données ci-dessus (par exemple, « bleu », « vert », « rouge », « nir », « swir_1 », « swir_2 ») sont des objets « xarray.DataArray ».
Nous pouvons inspecter les données dans ces objets « xarray.DataArray » en utilisant l’une des syntaxes suivantes :
ds["measurement_name"]
ou:
ds.measurement_name
Le fait de pouvoir accéder aux données de variables/mesures de données individuelles nous permet de manipuler et d’analyser les données de bandes satellites individuelles ou de couches spécifiques dans un ensemble de données. Par exemple, nous pouvons accéder aux données de la bande satellite proche infrarouge (c’est-à-dire « nir ») :
[4]:
print(ds.nir)
<xarray.DataArray 'nir' (time: 1, y: 1201, x: 966)>
array([[[2607, 2631, 2644, ..., 2293, 2256, 2268],
[2646, 2655, 2681, ..., 2263, 2251, 2273],
[2688, 2672, 2693, ..., 2225, 2233, 2265],
...,
[2721, 2733, 2755, ..., 3054, 2691, 2148],
[2704, 2728, 2745, ..., 2357, 1948, 1755],
[2708, 2741, 2734, ..., 1761, 1693, 1636]]], dtype=uint16)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.519e+06 -2.519e+06
* x (x) float64 2.378e+06 2.378e+06 ... 2.388e+06 2.388e+06
spatial_ref int32 6933
Attributes:
units: 1
nodata: 0
crs: epsg:6933
grid_mapping: spatial_ref
Notez que l’en-tête de l’objet nous informe qu’il s’agit d’un « xarray.DataArray » contenant des données pour la bande satellite « nir ».
Comme un « xarray.Dataset », le tableau inclut également des informations sur les dimensions des données (c’est-à-dire « (time: 1, y: 801, x: 644) »), les coordonnées et les attributs. Cette variable de données/mesure particulière contient des informations supplémentaires spécifiques à la bande « nir », notamment des détails sur la valeur nodata du tableau (c’est-à-dire « nodata: -999 »).
Remarque : pour une introduction plus approfondie aux structures de données « xarray », reportez-vous à la « documentation officielle de xarray » <http://xarray.pydata.org/en/stable/data-structures.html> »__
Personnalisation de la fonction « dc.load() »
La fonction « dc.load() » peut être personnalisée pour affiner une requête.
Les options de personnalisation incluent :
measurements:Cet argument est utilisé pour fournir une liste de noms de mesures à charger, comme indiqué dansdc.list_measurements(). Pour les ensembles de données satellite, les mesures contiennent des données pour chaque bande satellite individuelle (par exemple, proche infrarouge). Si elles ne sont pas fournies, toutes les mesures du produit seront renvoyées.crs :Le système de référence de coordonnées (CRS) des coordonnées « x » et « y » de la requête est supposé être « WGS84 »/« EPSG:4326 » à moins que le champ « crs » ne soit fourni, même si les données stockées se trouvent dans une autre projection ou si le paramètre « output_crs » est spécifié. Le paramètre « crs » est obligatoire si les coordonnées de votre requête se trouvent dans un autre CRS.group_by :Les ensembles de données satellite basés sur des scènes peuvent avoir plusieurs observations par jour avec des horodatages légèrement différents à mesure que le satellite collecte des données le long de son trajet. Ces observations peuvent être combinées en réduisant la dimension « temps » au niveau du jour à l’aide degroup_by=solar_day.« output_crs » et « resolution » : pour reprojeter ou modifier la résolution des données, renseignez les champs « output_crs » et « resolution ».
« réséchantillonnage » : cet argument vous permet de spécifier une méthode de rééchantillonnage spatial personnalisée à utiliser lorsque les données sont reprojetées dans un autre SCR.
Un exemple de syntaxe sur l’utilisation de ces options suit dans les cellules ci-dessous.
Pour obtenir de l’aide ou plus d’options de personnalisation, exécutez
help(dc.load)dans une cellule vide ou visitez la page de documentation de la fonction <https://datacube-core.readthedocs.io/en/latest/api/indexed-data/generate/datacube.Datacube.load.html>`__
Spécification des mesures
Par défaut, dc.load() chargera toutes les mesures d’un produit.
Pour charger les données des bandes satellites « rouge », « verte » et « bleue » uniquement, nous pouvons ajouter « measurements=[« rouge », « vert », « bleu »] » à notre requête :
[5]:
# Note the optional inclusion of the measurements list
ds_rgb = dc.load(product="gm_s2_annual",
measurements=["red", "green", "blue"],
x=(24.60, 24.80),
y=(-20.05, -20.25),
time=("2018-01-01", "2018-12-31"))
print(ds_rgb)
<xarray.Dataset>
Dimensions: (time: 1, y: 2400, x: 1930)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables:
red (time, y, x) uint16 1306 1272 1320 1299 ... 1385 1394 1363 1365
green (time, y, x) uint16 989 996 1037 1010 ... 1102 1108 1086 1095
blue (time, y, x) uint16 695 700 746 709 752 ... 784 785 791 766 771
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Notez que le composant Variables de données du « xarray.Dataset » inclut désormais uniquement les mesures spécifiées dans la requête (c’est-à-dire les bandes satellites « rouge », « verte » et « bleue »).
Chargement de données pour les coordonnées dans n’importe quel SCR
Par défaut, dc.load() suppose que les coordonnées x et y de votre requête sont fournies en degrés dans le SCR WGS84/EPSG:4326. Si vos coordonnées sont dans un système de coordonnées différent, vous devez le spécifier à l’aide du paramètre crs.
Dans l’exemple ci-dessous, nous chargeons des données pour un ensemble de coordonnées « x » et « y » définies dans Africa Albers Equal Area Conic (EPSG:6933), et nous nous assurons que la fonction « dc.load() » en tient compte en incluant « crs= »EPSG:6933 »`` :
[6]:
# Note the new `x` and `y` coordinates and `crs` parameter
ds_custom_crs = dc.load(product="gm_s2_annual",
time=("2018-01-01", "2018-12-31"),
x=(2373555, 2392845),
y=(-2507265, -2531265),
crs="EPSG:6933")
print(ds_custom_crs)
<xarray.Dataset>
Dimensions: (time: 1, y: 2401, x: 1930)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables: (12/14)
B02 (time, y, x) uint16 723 667 670 683 672 ... 775 784 785 791 766
B03 (time, y, x) uint16 1016 961 976 982 ... 1108 1102 1108 1086
B04 (time, y, x) uint16 1338 1258 1254 1269 ... 1392 1385 1394 1363
B05 (time, y, x) uint16 1638 1625 1592 1587 ... 1755 1756 1743 1735
B06 (time, y, x) uint16 1929 1923 1931 1931 ... 2213 2213 2185 2181
B07 (time, y, x) uint16 2098 2092 2103 2105 ... 2440 2440 2405 2399
... ...
B11 (time, y, x) uint16 3139 3107 3034 3026 ... 3361 3368 3345 3327
B12 (time, y, x) uint16 2298 2255 2172 2161 ... 2458 2465 2429 2410
SMAD (time, y, x) float32 0.001018 0.00113 ... 0.003506 0.003435
EMAD (time, y, x) float32 654.1 681.0 685.7 ... 905.2 855.7 845.2
BCMAD (time, y, x) float32 0.04878 0.05154 ... 0.05118 0.05052
COUNT (time, y, x) uint16 55 55 55 55 55 55 55 ... 55 54 54 54 54 54
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Reprojection CRS
Certaines applications peuvent nécessiter que vous exportiez vos données dans un SCR spécifique. Vous pouvez reprojeter vos données de sortie en spécifiant le nouveau « output_crs » et en identifiant la « résolution » requise.
Dans cet exemple, nous allons reprojeter nos données vers un nouveau SCR (UTM Zone 34S, « EPSG:32734 ») et une résolution (250 x 250 m). Notez que pour la plupart des SCR, la première valeur de résolution est négative (par exemple « (-250, 250) ») :
[7]:
ds_reprojected = dc.load(product="gm_s2_annual",
x=(24.60, 24.80),
y=(-20.05, -20.25),
time=("2018-01-01", "2018-12-31"),
output_crs="EPSG:32734",
resolution=(-250, 250))
print(ds_reprojected)
<xarray.Dataset>
Dimensions: (time: 1, y: 91, x: 87)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 7.779e+06 7.779e+06 ... 7.757e+06 7.756e+06
* x (x) float64 8.761e+05 8.764e+05 ... 8.974e+05 8.976e+05
spatial_ref int32 32734
Data variables: (12/14)
B02 (time, y, x) uint16 683 715 778 817 704 ... 792 747 706 704 744
B03 (time, y, x) uint16 940 997 1077 1117 ... 1046 1009 1006 1042
B04 (time, y, x) uint16 1189 1277 1373 1419 ... 1307 1251 1258 1284
B05 (time, y, x) uint16 1494 1604 1705 1744 ... 1664 1609 1618 1638
B06 (time, y, x) uint16 1818 1950 2033 2061 ... 2084 2026 2047 2069
B07 (time, y, x) uint16 1984 2128 2214 2239 ... 2293 2216 2248 2270
... ...
B11 (time, y, x) uint16 3198 3269 3321 3373 ... 3277 3069 3122 3181
B12 (time, y, x) uint16 2389 2407 2484 2533 ... 2375 2144 2199 2282
SMAD (time, y, x) float32 0.001581 0.001958 ... 0.003856 0.003551
EMAD (time, y, x) float32 780.1 794.3 768.2 ... 735.2 777.5 815.4
BCMAD (time, y, x) float32 0.06216 0.05727 ... 0.05445 0.05552
COUNT (time, y, x) uint16 55 56 56 54 55 54 54 ... 54 55 55 54 53 53
Attributes:
crs: EPSG:32734
grid_mapping: spatial_ref
Notez que l’attribut « crs » dans la section Attributs a été modifié en « EPSG:32734 ». En raison de la résolution plus élevée de 250 m, il y a désormais moins de pixels sur les dimensions « x » et « y » (par exemple, « x : 87, y : 91 » par rapport à « x : 1930, y : 2100 » dans les exemples précédents).
Méthodes de rééchantillonnage spatial
Lorsqu’un produit est reprojeté dans un SCR et/ou une résolution différents, la nouvelle grille de pixels peut différer des pixels d’entrée d’origine en termes de taille, de nombre et d’alignement. Il est donc nécessaire d’appliquer une règle de « rééchantillonnage » spatial qui alloue les valeurs des pixels d’entrée dans la nouvelle grille de pixels.
Par défaut, « dc.load() » rééchantillonne les valeurs de pixels à l’aide du rééchantillonnage du « voisin le plus proche », qui attribue à chaque nouveau pixel la valeur du pixel d’entrée le plus proche. Selon le type de données et l’analyse en cours, ce choix peut ne pas être le plus approprié (par exemple pour les données continues).
Le paramètre « resampling » dans « dc.load() » vous permet de choisir une méthode de rééchantillonnage personnalisée parmi les options suivantes :
"nearest", "cubic", "bilinear", "cubic_spline", "lanczos",
"average", "mode", "gauss", "max", "min", "med", "q1", "q3"
Par exemple, nous pouvons demander que toutes les données chargées soient rééchantillonnées à l’aide d’un rééchantillonnage « moyen » :
[8]:
# Note the additional `resampling` parameter
ds_averageresampling = dc.load(product="gm_s2_annual",
x=(24.60, 24.80),
y=(-20.05, -20.25),
time=("2018-01-01", "2018-12-31"),
resolution=(-250, 250),
resampling="average")
print(ds_averageresampling)
<xarray.Dataset>
Dimensions: (time: 1, y: 96, x: 78)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.508e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables: (12/14)
B02 (time, y, x) uint16 795 827 656 701 808 ... 753 768 765 750 717
B03 (time, y, x) uint16 1086 1083 917 989 ... 1075 1067 1058 1025
B04 (time, y, x) uint16 1390 1406 1172 1271 ... 1335 1328 1310 1270
B05 (time, y, x) uint16 1713 1655 1494 1613 ... 1695 1687 1673 1634
B06 (time, y, x) uint16 2032 1862 1898 2049 ... 2122 2109 2112 2060
B07 (time, y, x) uint16 2211 2019 2087 2255 ... 2336 2319 2319 2254
... ...
B11 (time, y, x) uint16 3547 3632 3145 3249 ... 3381 3283 3209 3092
B12 (time, y, x) uint16 2752 2959 2254 2301 ... 2487 2367 2288 2184
SMAD (time, y, x) float32 0.001492 0.0008584 ... 0.003857 0.003664
EMAD (time, y, x) float32 811.6 630.3 642.9 ... 865.0 836.6 757.6
BCMAD (time, y, x) float32 0.05379 0.04321 ... 0.05563 0.05322
COUNT (time, y, x) uint16 54 55 55 54 53 53 52 ... 55 53 53 55 53 54
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Vous pouvez également fournir un dictionnaire Python pour demander une méthode d’échantillonnage différente pour différentes mesures. Cela peut être particulièrement utile lorsque certaines mesures contiennent des données catégorielles qui nécessitent des méthodes de rééchantillonnage telles que « nearest » ou « mode » qui ne modifient pas les valeurs des pixels d’entrée.
Dans l’exemple ci-dessous, nous spécifions resampling={"red": "nearest", "*": "average"}, qui utilisera le rééchantillonnage du voisin « le plus proche » pour la bande satellite « rouge » uniquement. "*": "average" appliquera le rééchantillonnage « moyen » pour toutes les autres bandes satellites :
[9]:
ds_customresampling = dc.load(product="gm_s2_annual",
x=(24.60, 24.80),
y=(-20.05, -20.25),
time=("2018-01-01", "2018-12-31"),
resolution=(-250, 250),
resampling={"red": "nearest", "*": "average"})
print(ds_customresampling)
<xarray.Dataset>
Dimensions: (time: 1, y: 96, x: 78)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.508e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables: (12/14)
B02 (time, y, x) uint16 795 827 656 701 808 ... 753 768 765 750 717
B03 (time, y, x) uint16 1086 1083 917 989 ... 1075 1067 1058 1025
B04 (time, y, x) uint16 1390 1406 1172 1271 ... 1335 1328 1310 1270
B05 (time, y, x) uint16 1713 1655 1494 1613 ... 1695 1687 1673 1634
B06 (time, y, x) uint16 2032 1862 1898 2049 ... 2122 2109 2112 2060
B07 (time, y, x) uint16 2211 2019 2087 2255 ... 2336 2319 2319 2254
... ...
B11 (time, y, x) uint16 3547 3632 3145 3249 ... 3381 3283 3209 3092
B12 (time, y, x) uint16 2752 2959 2254 2301 ... 2487 2367 2288 2184
SMAD (time, y, x) float32 0.001492 0.0008584 ... 0.003857 0.003664
EMAD (time, y, x) float32 811.6 630.3 642.9 ... 865.0 836.6 757.6
BCMAD (time, y, x) float32 0.05379 0.04321 ... 0.05563 0.05322
COUNT (time, y, x) uint16 54 55 55 54 53 53 52 ... 55 53 53 55 53 54
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Remarque : pour plus d’informations sur les méthodes de rééchantillonnage spatial, consultez le « guide suivant <https://rasterio.readthedocs.io/en/stable/topics/resampling.html> »__
Chargement de données à l’aide de la syntaxe du dictionnaire de requêtes
Il est souvent utile de réutiliser un ensemble de paramètres de requête pour charger des données à partir de plusieurs produits. Pour ce faire, nous pouvons charger des données à l’aide de la syntaxe « dictionnaire de requêtes ». Cela implique de placer les paramètres de requête que nous avons utilisés pour charger les données ci-dessus dans un objet dictionnaire Python que nous pouvons réutiliser pour plusieurs chargements de données :
[10]:
query = {"x": (24.60, 24.80),
"y": (-20.05, -20.25),
"time": ("2018-01-01", "2018-12-31")}
Nous pouvons ensuite utiliser cet objet de dictionnaire de requêtes comme entrée pour « dc.load() ».
La syntaxe
**ci-dessous est l’opérateur de « décompression d’arguments de mots-clés » de Python. Cet opérateur prend les paramètres de requête nommés répertoriés dans le dictionnaire que nous avons créé (par exemple"x": (153.3, 153.4)), et les « décompresse » dans la fonctiondc.load()en tant que nouveaux arguments. Pour plus d’informations sur les opérateurs de décompression, reportez-vous à la documentation Python
[11]:
ds = dc.load(product="gm_s2_annual",
**query)
print(ds)
<xarray.Dataset>
Dimensions: (time: 1, y: 2400, x: 1930)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables: (12/14)
B02 (time, y, x) uint16 695 700 746 709 752 ... 784 785 791 766 771
B03 (time, y, x) uint16 989 996 1037 1010 ... 1102 1108 1086 1095
B04 (time, y, x) uint16 1306 1272 1320 1299 ... 1385 1394 1363 1365
B05 (time, y, x) uint16 1637 1589 1587 1624 ... 1756 1743 1735 1718
B06 (time, y, x) uint16 1934 1924 1926 1963 ... 2213 2185 2181 2161
B07 (time, y, x) uint16 2103 2095 2100 2137 ... 2440 2405 2399 2374
... ...
B11 (time, y, x) uint16 3118 3034 3038 3118 ... 3368 3345 3327 3253
B12 (time, y, x) uint16 2266 2180 2183 2234 ... 2465 2429 2410 2343
SMAD (time, y, x) float32 0.001054 0.001198 ... 0.003435 0.00359
EMAD (time, y, x) float32 696.9 698.4 701.8 ... 855.7 845.2 803.1
BCMAD (time, y, x) float32 0.05079 0.05238 ... 0.05052 0.05244
COUNT (time, y, x) uint16 55 55 55 55 55 55 55 ... 54 54 54 54 54 54
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Les dictionnaires de requête peuvent contenir n’importe quel ensemble de paramètres qui seraient normalement fournis à « dc.load() » :
[12]:
query = {"x": (24.60, 24.80),
"y": (-20.05, -20.25),
"time": ("2018-01-01", "2018-12-31"),
"output_crs": "EPSG:32734",
"resolution": (-250, 250)}
ds_s2 = dc.load(product="gm_s2_annual",
**query)
print(ds_s2)
<xarray.Dataset>
Dimensions: (time: 1, y: 91, x: 87)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 7.779e+06 7.779e+06 ... 7.757e+06 7.756e+06
* x (x) float64 8.761e+05 8.764e+05 ... 8.974e+05 8.976e+05
spatial_ref int32 32734
Data variables: (12/14)
B02 (time, y, x) uint16 683 715 778 817 704 ... 792 747 706 704 744
B03 (time, y, x) uint16 940 997 1077 1117 ... 1046 1009 1006 1042
B04 (time, y, x) uint16 1189 1277 1373 1419 ... 1307 1251 1258 1284
B05 (time, y, x) uint16 1494 1604 1705 1744 ... 1664 1609 1618 1638
B06 (time, y, x) uint16 1818 1950 2033 2061 ... 2084 2026 2047 2069
B07 (time, y, x) uint16 1984 2128 2214 2239 ... 2293 2216 2248 2270
... ...
B11 (time, y, x) uint16 3198 3269 3321 3373 ... 3277 3069 3122 3181
B12 (time, y, x) uint16 2389 2407 2484 2533 ... 2375 2144 2199 2282
SMAD (time, y, x) float32 0.001581 0.001958 ... 0.003856 0.003551
EMAD (time, y, x) float32 780.1 794.3 768.2 ... 735.2 777.5 815.4
BCMAD (time, y, x) float32 0.06216 0.05727 ... 0.05445 0.05552
COUNT (time, y, x) uint16 55 56 56 54 55 54 54 ... 54 55 55 54 53 53
Attributes:
crs: EPSG:32734
grid_mapping: spatial_ref
Nous disposons désormais d’une requête réutilisable, que nous pouvons facilement utiliser pour charger des données à partir d’un autre produit. Par exemple, nous pouvons charger les données du résumé annuel des observations de l’eau depuis l’espace (WOfS) pour la même étendue, la même période, le même SCR de sortie et la même résolution que ceux pour lesquels nous venons de charger les données géomédianes de Landsat 8 :
[13]:
ds_wofs = dc.load(product="wofs_ls_summary_annual",
**query)
print(ds_wofs)
<xarray.Dataset>
Dimensions: (time: 1, y: 91, x: 87)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 7.779e+06 7.779e+06 ... 7.757e+06 7.756e+06
* x (x) float64 8.761e+05 8.764e+05 ... 8.974e+05 8.976e+05
spatial_ref int32 32734
Data variables:
count_wet (time, y, x) int16 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0
count_clear (time, y, x) int16 55 55 56 57 57 56 57 ... 30 30 30 30 29 29
frequency (time, y, x) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0
Attributes:
crs: EPSG:32734
grid_mapping: spatial_ref
Autres astuces utiles
Chargement de données « comme » un autre ensemble de données
Une autre option pour charger des données correspondantes à partir de plusieurs produits consiste à utiliser le paramètre « like » de « dc.load() ». Cela copiera l’étendue spatiale et temporelle et le SCR/la résolution d’un ensemble de données existant, et utilisera ces paramètres pour charger de nouvelles données à partir d’un nouveau produit.
Dans l’exemple ci-dessous, nous chargeons un autre ensemble de données WOfS qui correspond exactement à l’ensemble de données « ds_s2 » que nous avons chargé précédemment :
[14]:
ds_wofs = dc.load(product="wofs_ls_summary_annual",
like=ds_s2)
print(ds_wofs)
<xarray.Dataset>
Dimensions: (time: 1, y: 91, x: 87)
Coordinates:
* time (time) datetime64[ns] 2018-07-02T11:59:59.999999
* y (y) float64 7.779e+06 7.779e+06 ... 7.757e+06 7.756e+06
* x (x) float64 8.761e+05 8.764e+05 ... 8.974e+05 8.976e+05
spatial_ref int32 32734
Data variables:
count_wet (time, y, x) int16 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0
count_clear (time, y, x) int16 55 55 56 57 57 56 57 ... 30 30 30 30 29 29
frequency (time, y, x) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0
Attributes:
crs: PROJCS["WGS 84 / UTM zone 34S",GEOGCS["WGS 84",DATUM["WGS_...
grid_mapping: spatial_ref
Ajout d’une barre de progression
Lors du chargement de grandes quantités de données, il peut être utile de visualiser la progression du chargement des données. Le paramètre progress_cbk dans dc.load() nous permet d’ajouter une barre de progression qui indiquera la progression du chargement. Dans cet exemple, nous allons charger 5 années de données (2013, 2014, 2015, 2016 et 2017) à partir du produit ga_ls8c_wofs_2_annual_summary avec une barre de progression :
[15]:
query = {"x": (24.60, 24.80),
"y": (-20.05, -20.25),
"time": ("2013", "2016")}
ds_progress = dc.load(product="wofs_ls_summary_annual",
progress_cbk=with_ui_cbk(),
**query)
print(ds_progress)
<xarray.Dataset>
Dimensions: (time: 4, y: 801, x: 644)
Coordinates:
* time (time) datetime64[ns] 2013-07-02T11:59:59.999999 ... 2016-07...
* y (y) float64 -2.507e+06 -2.507e+06 ... -2.531e+06 -2.531e+06
* x (x) float64 2.374e+06 2.374e+06 ... 2.393e+06 2.393e+06
spatial_ref int32 6933
Data variables:
count_wet (time, y, x) int16 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0
count_clear (time, y, x) int16 45 45 45 45 45 44 44 ... 32 32 32 32 33 33
frequency (time, y, x) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0
Attributes:
crs: epsg:6933
grid_mapping: spatial_ref
Étapes suivantes recommandées
Pour des informations plus avancées sur l’utilisation de Jupyter Notebooks ou JupyterLab, vous pouvez explorer la page de documentation de JupyterLab.
Pour continuer à travailler sur les cahiers de ce guide du débutant, les cahiers suivants sont conçus pour être travaillés dans l’ordre suivant :
Chargement des données (ce carnet)
Une fois que vous avez terminé les six didacticiels ci-dessus, rejoignez les utilisateurs avancés pour explorer :
Le répertoire « Datasets » du référentiel, où vous pouvez explorer en profondeur les produits DE Africa.
Le répertoire « Code fréquemment utilisé », qui contient un livre de recettes de techniques et méthodes courantes pour l’analyse des données DE Africa.
Le répertoire « Exemples du monde réel », qui fournit des flux de travail plus complexes et des études de cas d’analyse.
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 :
[16]:
print(datacube.__version__)
1.8.15
Dernier test :
[17]:
from datetime import datetime
datetime.today().strftime('%Y-%m-%d')
[17]:
'2023-08-11'