La surveillance de l'environnement, l'agriculture, l'urbanisme, la gestion des catastrophes et les études sur le changement climatique ont tous bénéficié de l'analyse des images satellitaires.
Nous pouvons acquérir des informations importantes sur les caractéristiques, les changements et la dynamique de notre planète en exploitant la quantité massive de données enregistrées par les satellites d'observation de la Terre.
Python, un langage de programmation polyvalent et puissant, offre un riche écosystème de bibliothèques et d'outils pour un traitement rapide et efficace des images satellites.
L'utilisation de analyse d'images satellitaires ouvre un monde de possibilités. Il nous permet d'extraire des informations utiles à partir de photos satellites, telles que la catégorisation de la couverture terrestre, l'évaluation de la santé de la végétation, le suivi de l'expansion urbaine et la cartographie du littoral.
Nous pouvons facilement traiter, afficher et analyser des images satellites en exploitant la polyvalence de Python et des modules tels que rasterio, numpy et matplotlib.
L'un des principaux avantages de l'utilisation de Python pour l'analyse d'images satellites est sa large gamme de modules de traitement de données géospatiales.
Rasterio, par exemple, possède une interface simple pour lire et modifier les informations raster, ce qui le rend approprié pour travailler avec des fichiers d'imagerie satellite.
Le module numpy fournit des opérations de tableau sophistiquées pour effectuer des calculs rapides et des statistiques sur les données d'image. Matplotlib nous permet également de générer des visuels pertinents pour aider à l'interprétation et à la communication des résultats analytiques.
Dans les sections suivantes, nous examinerons des exemples réels et des extraits de code pour montrer comment Python peut être utilisé pour analyser des photos satellites.
Nous verrons comment ouvrir des photos satellites, visualiser des données d'imagerie, extraire des métadonnées, calculer des statistiques de bande et exécuter des analyses particulières comme l'indice de végétation par différence normalisée (NDVI).
Ces exemples vous aideront à vous lancer dans le sujet intrigant de l'analyse d'images satellites avec Python.
Tout d'abord, nous devons importer certaines bibliothèques pour nous aider dans notre tâche.
import rasterio
import matplotlib.pyplot as plt
import numpy as np
1. Visualisation et ouverture de l'image satellite
Nous utiliserons la bibliothèque Rasterio dans cette section pour accéder à l'image satellite fournie par le satellite_image_path.
Le fichier image est ouvert à l'aide de la méthode rasterio.open() et l'objet résultant, satellite_image, représente l'image ouverte.
Pour cette tâche, j'ai utilisé l'image de ce lien : https://unsplash.com/photos/JiuVoQd-ZLk et l'ai enregistrée sur mon ordinateur sous le nom "satellite.jpg".
# Open the satellite image using rasterio
satellite_image_path = 'satellite.jpg'
satellite_image = rasterio.open(satellite_image_path)
Après avoir ouvert l'image, nous la lisons comme un tableau à l'aide de la fonction read() de l'objet image_satellite. Les valeurs de pixel pour chaque bande des images satellites sont stockées dans la matrice d'images.
# Read the image as an array
image_array = satellite_image.read()
Pour évaluer visuellement l'image satellite, nous utilisons l'outil matplotlib.pyplot pour générer une figure de 10 × 10 pouces.
Le tableau d'images est affiché à l'aide de la méthode imshow(). L'opération de transposition(1, 2, 0) est utilisée pour réorganiser les dimensions du tableau d'image pour s'adapter à l'ordre anticipé par imshow().
Enfin, axis('off') masque les étiquettes des axes, donnant une vue claire de l'image satellite.
# Visualize the image
plt.figure(figsize=(10, 10))
plt.imshow(image_array.transpose(1, 2, 0))
plt.axis('off')
plt.show()
2. Extraction de métadonnées
Nous extrayons des informations de métadonnées vitales sur l'image satellite après l'avoir ouverte et affichée. Ces informations nous aident à comprendre les qualités de l'image et offrent un contexte pour une enquête future.
image_width = satellite_image.width
image_height = satellite_image.height
image_crs = satellite_image.crs
image_count = satellite_image.count
print("Image Width:", image_width)
print("Image Height:", image_height)
print("Coordinate Reference System:", image_crs)
print("Number of Bands:", image_count)
En utilisant les attributs width et height de l'objet satellite_image, nous extrayons la largeur et la hauteur de l'image. La propriété crs est utilisée pour récupérer le système de référence de coordonnées (CRS) de l'image.
Le CRS donne des informations sur le système de référence spatiale de l'image, ce qui nous permet de faire correspondre les coordonnées de l'image aux lieux du monde réel.
Enfin, nous utilisons l'attribut count de l'objet satellite_image pour calculer le nombre de bandes dans l'image. Ces données sont essentielles pour une analyse ultérieure car elles nous permettent d'obtenir les valeurs de pixel pour chaque bande du tableau d'images.
3. Calcul des statistiques de bande
Nous calculons des statistiques pour chaque bande du tableau d'images dans cette partie. Une boucle parcourt chaque bande et les fonctions min, max, mean et std de la bibliothèque numpy sont utilisées pour calculer ces statistiques.
Une liste de dictionnaires stocke les statistiques pour chaque bande.
band_stats = []
for band in range(image_count):
band_data = image_array[band]
band_min = np.min(band_data)
band_max = np.max(band_data)
band_mean = np.mean(band_data)
band_std = np.std(band_data)
band_stats.append({'Band': band+1, 'Min': band_min, 'Max': band_max, 'Mean': band_mean, 'Std': band_std})
print("Band Statistics:")
for stats in band_stats:
print(stats)
La boucle parcourt chaque bande, la bande variable représentant l'indice de bande. En utilisant image_array[band], nous extrayons les valeurs de pixel du tableau d'image pour chaque bande.
Ensuite, pour la bande actuelle, les fonctions np.min(), np.max(), np.mean() et np.std() sont utilisées pour déterminer le minimum, le maximum, la moyenne et l'écart type du pixel valeurs.
Les données calculées pour chaque bande sont enregistrées dans un dictionnaire avec des clés telles que "Bande", "Min", "Max", "Moyenne" et "Std". Chaque dictionnaire est ajouté à la liste des statistiques de bande. Enfin, les données de chaque bande sont imprimées sur la console.
4. Calcul du NDVI (indice de végétation par différence normalisée)
Le NDVI est une mesure populaire pour mesurer la santé des plantes. Dans cette section, nous vérifions si l'image comprend au moins quatre bandes, qui sont nécessaires pour le calcul du NDVI.
red_band = None
nir_band = None
if image_count >= 4:
red_band = image_array[2] # assuming red band is at index 2
nir_band = image_array[3] # assuming near-infrared band is at index 3
if red_band is not None and nir_band is not None:
ndvi = (nir_band - red_band) / (nir_band + red_band)
# Visualize the NDVI
plt.figure(figsize=(10, 10))
plt.imshow(ndvi, cmap='RdYlGn')
plt.colorbar(label='NDVI')
plt.title('Normalized Difference Vegetation Index (NDVI)')
plt.axis('off')
plt.show()
else:
print("Error: The satellite image does not have the required bands for NDVI calculation.")
Pour commencer, nous définissons les variables red_band et nir_band sur None. La variable image_count est ensuite utilisée pour déterminer si l'image contient au moins quatre bandes.
Si tel est le cas, nous en déduisons que la bande rouge est l'indice 2 et la bande proche infrarouge (NIR) est l'indice 3. Les bandes correspondantes du tableau d'images sont affectées aux variables red_band et nir_band.
Si les bandes rouge et NIR sont accessibles, le NDVI est calculé à l'aide de la formule (NIR - Rouge) / (NIR + Rouge). Les nombres NDVI qui en résultent indiquent l'indice de végétation pour chaque pixel de l'image.
Nous voyons ensuite le NDVI en créant une nouvelle figure et en affichant le tableau NDVI à l'aide de imshow(). La méthode colorbar() ajoute une barre de couleurs au tracé, donnant aux valeurs NDVI une référence visuelle.
Pour nous concentrer entièrement sur l'affichage NDVI, nous spécifions en outre une légende pour le tracé et supprimons les étiquettes d'axe avec axis('off'). Enfin, le tracé est affiché avec plt.show().
Un message d'erreur est écrit sur la console s'il manque à l'image les bandes requises pour le calcul du NDVI (c'est-à-dire moins de quatre bandes).
5. Mettre fin à l'image satellite
Il est recommandé d'utiliser la fonction close() pour fermer le fichier d'image satellite après avoir effectué l'analyse et la visualisation. Cela libère toutes les ressources système liées au fichier image.
satellite_image.close()
Voici ma solution:
C'est tout!
notes finales
Le rôle de Python dans l'aide à l'étude de ces ensembles de données massifs devient de plus en plus important à mesure que la disponibilité et la résolution des images satellite augmentent.
La possibilité d'utiliser Python pour accéder, traiter, analyser et afficher des images satellite ouvre la voie à des applications créatives et à des idées qui peuvent conduire à de bons changements et à une meilleure connaissance de notre monde.
N'oubliez pas d'explorer la vaste sélection de ressources, de didacticiels et de bibliothèques disponibles pour accroître vos connaissances et vos capacités tout au long de votre aventure dans l'analyse d'images satellites à l'aide de Python.
Continuez à vous intéresser, explorez et utilisez les capacités de Python pour découvrir les mystères enfouis dans les images satellites.
Soyez sympa! Laissez un commentaire