Comment tracer une heatmap pour les régions polaires en python avec cartopy et matplotlib ?

Introduction

Lorsqu'on travaille avec des données géospatiales, il est courant de tracer des cartes des régions polaires, comme l'Arctique ou l'Antarctique. Ce guide montre comment créer une heatmap sur les régions polaires en utilisant cartopy, Matplotlib et Python. Cartopy est particulièrement utile pour la visualisation des données géospatiales car il prend en charge les projections et peut gérer facilement les caractéristiques géographiques.

Tracer une heatmap sur l'Antarctique en utilisant Cartopy

Carte basique de l'Antarctique

Cet exemple montre comment tracer une carte basique de l'Antarctique et superposer une limite circulaire pour mettre en valeur la région polaire la plus au sud.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import cartopy.feature
import matplotlib.path as mpath

fig = plt.figure(figsize=[10, 5])

ax1 = plt.subplot(1, 2, 1, projection=ccrs.SouthPolarStereo())

# Limiter la carte à -60 degrés de latitude et en dessous.
ax1.set_extent([-180, 180, -90, -60], ccrs.PlateCarree())

ax1.add_feature(cartopy.feature.LAND)
ax1.add_feature(cartopy.feature.OCEAN)

ax1.gridlines()

theta = np.linspace(0, 2*np.pi, 100)
center, radius = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
circle = mpath.Path(verts * radius + center)

ax1.set_boundary(circle, transform=ax1.transAxes)

plt.savefig("cartopy_antarctica_01.png", bbox_inches='tight', dpi=200)

plt.show()

Explication :
- La projection stéréographique polaire sud (ccrs.SouthPolarStereo) est utilisée car elle représente avec précision les régions polaires.
- set_extent([-180, 180, -90, -60]) limite la carte aux latitudes inférieures à -60 degrés, en se concentrant sur l'Antarctique.
- Limite circulaire : Ceci est réalisé en utilisant matplotlib.path, assurant que la carte a une limite lisse ressemblant à la forme circulaire des projections polaires.
- Ajout de caractéristiques : La méthode add_feature de Cartopy permet d'ajouter des caractéristiques géographiques comme la terre et l'océan à la carte.

Note : Vous pouvez également créer une version plus simple de la carte sans la limite circulaire, qui visualise tout de même efficacement la région polaire. Cette approche simplifie le code en se concentrant uniquement sur la définition de l'étendue de la carte et des caractéristiques de base comme la terre, l'océan et les lignes de grille.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import cartopy.feature
import cartopy.crs as ccrs
import matplotlib.pyplot as plt

# Créer une figure avec la projection stéréographique polaire sud
fig = plt.figure(figsize=[10, 5])
ax1 = plt.subplot(1, 2, 1, projection=ccrs.SouthPolarStereo())

# Définir l'étendue de la carte pour couvrir les latitudes inférieures à -60 degrés
ax1.set_extent([-180, 180, -90, -60], ccrs.PlateCarree())

# Ajouter des caractéristiques géographiques pour le contexte : terre et océan
ax1.add_feature(cartopy.feature.LAND, zorder=0)
ax1.add_feature(cartopy.feature.OCEAN, zorder=0)

# Afficher les lignes de grille pour fournir des points de référence pour la longitude et la latitude
ax1.gridlines()

# Enregistrer la figure avec une haute résolution et l'afficher
plt.savefig("cartopy_antarctica_02.png", bbox_inches='tight', dpi=200)
plt.show()

Explication :
- Carte simplifiée : Cette version exclut la limite circulaire, rendant le code plus facile à suivre et utile lorsque la projection complète de la région polaire est suffisante.
- Étendue : La carte se concentre sur la région polaire en définissant l'étendue de -180 à 180 degrés de longitude et de -90 à -60 degrés de latitude.
- Caractéristiques géographiques : Les caractéristiques LAND et OCEAN intégrées à Cartopy fournissent un contexte géographique simple mais efficace.
- Lignes de grille : L'ajout de lignes de grille offre des références utiles pour l'orientation spatiale de la carte.

Cette approche simplifiée est idéale pour les cas où vous souhaitez une représentation visuelle directe de l'Antarctique sans avoir besoin de mettre l'accent sur des régions spécifiques ou d'appliquer des limites personnalisées.

Tracer une heatmap sur l'Antarctique en utilisant des données réelles (exemple 1)

Dans cet exemple, nous chargeons des données géospatiales réelles (à partir d'un fichier MODIS) et les traçons sous forme de heatmap sur l'Antarctique. L'objectif est de visualiser des données géospatiales en utilisant imshow de Cartopy pour le tracé raster.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from cartopy import config
from matplotlib.pyplot import figure
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import matplotlib.path as mpath
import numpy as np

data = np.loadtxt('modis_myd06_cpop_2d_hist_1b1_grid.txt')

fig = plt.figure(num=None, figsize=(8, 6), dpi=80, edgecolor='k')

ax = plt.axes(projection=ccrs.SouthPolarStereo())

ax.set_extent([-180, 180, -90, -45], ccrs.PlateCarree())

theta = np.linspace(0, 2*np.pi, 200)
center, radius = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
circle = mpath.Path(verts * radius + center)

ax.set_boundary(circle, transform=ax.transAxes)

ax.imshow(data.T, origin='lower', extent=[-180,180,-90,90], transform=ccrs.PlateCarree(),cmap='jet',vmin=0, vmax=1.0)

ax.coastlines()

plt.title("Tracer une carte de chaleur avec cartopy en python", fontsize=12)

plt.savefig("cartopy_antarctica_03.png", bbox_inches='tight', dpi=200)

plt.show()

Explication :
- Chargement des données : La heatmap est créée à partir des données d'un fichier, tel que les données de télédétection MODIS. Les données sont visualisées sous forme de grille 2D sur l'Antarctique.
- Fonction imshow : Cette fonction trace les données chargées sur la carte. L'option extent définit la boîte englobante pour l'image, et transform=ccrs.PlateCarree() aligne les données de la grille sur les coordonnées géographiques.
- Carte des couleurs : Le colormap 'jet' est utilisé pour la carte de chaleur, et peut être ajusté selon la plage des données (vmin, vmax).

Tracer une heatmap sur l'Antarctique en utilisant des données réelles (exemple 2)

Voici une autre variante du tracé une heatmap avec Cartopy. Similaire à l'exemple 1, mais avec des données plus simples et sans la limite circulaire.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from cartopy import config
from matplotlib.pyplot import figure
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import numpy as np

data = np.loadtxt('modis_myd06_cpop_2d_hist_1b1_grid.txt')

fig = plt.figure(num=None, figsize=(8, 6), dpi=80, edgecolor='k')

ax = plt.axes(projection=ccrs.SouthPolarStereo())

ax.set_extent([-180, 180, -90, -60], ccrs.PlateCarree())

ax.imshow(data.T, origin='lower', extent=[-180,180,-90,90], transform=ccrs.PlateCarree(),cmap='jet',vmin=0, vmax=1.0)

ax.coastlines()

plt.title("Tracer une carte de chaleur avec cartopy en python", fontsize=12)

plt.savefig("cartopy_antarctica_04.png", bbox_inches='tight', dpi=200)

Explication :
Cette version suit la même logique mais sans le recadrage circulaire, ce qui la rend idéale pour des visualisations plus simples.

Commentaires finaux

• Projections : Le choix de la projection, comme SouthPolarStereo, est essentiel lors du travail avec des données polaires pour éviter les distorsions.
• Limites : Utiliser set_boundary() permet de contrôler la portion de la carte affichée, permettant ainsi de se concentrer sur des régions circulaires comme les zones polaires.
• Cartes thermiques : Cartopy, en combinaison avec la fonction imshow() de Matplotlib, offre un moyen flexible de visualiser des données géospatiales. Expérimentez avec les palettes de couleurs (cmap) et ajustez les valeurs vmin et vmax en fonction de l'étendue de vos données.

Ce guide devrait vous aider à débuter avec la visualisation de données polaires et la création de cartes thermiques sur l'Antarctique à l’aide de Cartopy et Matplotlib.

Tracer une heatmap sur l'Arctique avec Cartopy

Ce guide montre comment tracer une heatmap sur la région arctique à l’aide de bibliothèques Python telles que Cartopy et Matplotlib. Nous couvrirons la création d’une projection cartographique basique de l’Arctique et sa personnalisation pour s’adapter à une limite circulaire en utilisant la projection stéréographique polaire nord (North Polar Stereographic).

Carte basique de l'Arctique

Cet exemple présente la création d'une carte basique de l'Arctique à l'aide de la projection NorthPolarStereo de Cartopy, conçue pour représenter avec précision les régions polaires.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import cartopy.feature
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import matplotlib.path as mpath
import numpy as np

# Créer la figure et l'axe en utilisant la projection stéréographique polaire nord
fig = plt.figure(figsize=[10, 5])
ax1 = plt.subplot(1, 2, 1, projection=ccrs.NorthPolarStereo())

# Définir l'étendue de la carte : se concentrer sur les latitudes entre 60 et 90 degrés (région arctique)
ax1.set_extent([-180, 180, 60, 90], ccrs.PlateCarree())

# Ajouter les lignes de côte pour le contexte géographique
ax1.coastlines()

# Ajouter les lignes de grille pour montrer les marqueurs de latitude et de longitude
ax1.gridlines()

# Définir une limite circulaire pour recadrer la carte dans une région circulaire
theta = np.linspace(0, 2 * np.pi, 100)
centre, rayon = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
cercle = mpath.Path(verts * rayon + centre)

# Appliquer la limite circulaire à la carte polaire pour se concentrer sur la région arctique
ax1.set_boundary(cercle, transform=ax1.transAxes)

# Ajouter un titre
plt.title('Comment tracer une carte thermique sur les régions polaires \n avec Python, Cartopy et Matplotlib ?', 
          fontsize=10)

# Enregistrer la figure en tant que fichier PNG haute résolution et l’afficher
plt.savefig("cartopy_arctica_01.png", bbox_inches='tight', dpi=200)
plt.show()

Explication :

• Projection : La projection NorthPolarStereo est utilisée pour cartographier les régions polaires, garantissant une précision dans la région arctique à haute latitude.
• Étendue : La carte couvre les longitudes de -180 à 180 degrés et les latitudes de 60 à 90 degrés, capturant ainsi l'Arctique.
• Caractéristiques géographiques : Ajouter des lignes de côte et des lignes de grille fournit un contexte utile pour interpréter les informations spatiales de la carte.
• Limite circulaire : La carte est recadrée à l'aide d'une limite circulaire, concentrant l'attention sur la région autour du pôle Nord.

Carte simplifiée de l'Arctique sans limite circulaire

Si vous préférez une version plus simple sans la limite circulaire, le code suivant offre une approche directe :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import cartopy.feature
import cartopy.crs as ccrs
import matplotlib.pyplot as plt

fig = plt.figure(figsize=[10, 5])

ax1 = plt.subplot(1, 2, 1, projection=ccrs.NorthPolarStereo())

ax1.set_extent([-180, 180, 60, 90], ccrs.PlateCarree())

ax1.coastlines()

# Ajouter un titre
plt.title('Comment tracer une carte thermique sur les régions polaires \n avec Python, Cartopy et Matplotlib ?', 
          fontsize=10)

plt.savefig("cartopy_arctica_02.png", bbox_inches='tight', dpi=200)
plt.show()

Tracer une heatmap sur l'Arctique en utilisant des données réelles (exemple 1)

Dans cet exemple, nous chargeons des données géospatiales réelles (d'un fichier MODIS) et les traçons en tant que heatmap sur l'Arctique. L'objectif est de visualiser les données géospatiales à l’aide de imshow() de Cartopy pour le tracé raster.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from cartopy import config
from matplotlib.pyplot import figure
import cartopy.crs as ccrs
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(num=None, figsize=(8, 6), dpi=80, edgecolor='k')

ax = plt.axes(projection=ccrs.NorthPolarStereo())

ax.set_extent([-180, 180, 60, 90], ccrs.PlateCarree())

im = ax.imshow(data, extent=[-180,180,-90,90], transform=ccrs.PlateCarree(), cmap='jet', alpha=0.6)

ax.coastlines()

plt.colorbar(im)

plt.title('Comment tracer une carte thermique sur les régions polaires \n avec Python, Cartopy et Matplotlib ?', 
          fontsize=10)

# Enregistrer la figure en tant que fichier PNG haute résolution et l’afficher
plt.savefig("cartopy_arctica_03.png", bbox_inches='tight', dpi=200)
plt.show()

Références