Los estudios de monitoreo ambiental, agricultura, planificación urbana, gestión de desastres y cambio climático se han beneficiado del análisis de imágenes satelitales.
Podemos adquirir conocimientos significativos sobre las características, los cambios y la dinámica de nuestro planeta explotando la enorme cantidad de datos registrados por los satélites de observación de la Tierra.
Python, un lenguaje de programación versátil y sólido, ofrece un rico ecosistema de bibliotecas y herramientas para el procesamiento rápido y efectivo de imágenes satelitales.
El uso de análisis de imágenes satelitales abre un mundo de posibilidades. Nos permite extraer información útil de las fotos satelitales, como la categorización de la cobertura del suelo, la evaluación de la salud de la vegetación, el seguimiento de la expansión urbana y el mapeo de la costa.
Podemos procesar, mostrar y analizar fácilmente imágenes satelitales aprovechando la versatilidad de Python y módulos como rasterio, numpy y matplotlib.
Uno de los principales beneficios de usar Python para el análisis de imágenes satelitales es su amplia gama de módulos de procesamiento de datos geoespaciales.
Rasterio, por ejemplo, tiene una interfaz simple para leer y modificar información raster, lo que lo hace adecuado para trabajar con archivos de imágenes satelitales.
El módulo numpy proporciona operaciones de matriz sofisticadas para realizar cálculos rápidos y estadísticas sobre datos de imágenes. Matplotlib también nos permite generar imágenes relevantes para ayudar en la interpretación y comunicación de los resultados analíticos.
En las siguientes secciones, veremos ejemplos reales y fragmentos de código para mostrar cómo se puede usar Python para analizar fotos satelitales.
Repasaremos cómo abrir fotos satelitales, visualizar datos de imágenes, extraer metadatos, calcular estadísticas de banda y ejecutar análisis particulares como el Índice de vegetación de diferencia normalizada (NDVI).
Estos ejemplos lo ayudarán a iniciarse en el intrigante tema del análisis de imágenes satelitales con Python.
Primero, necesitamos importar algunas bibliotecas para ayudarnos con nuestra tarea.
import rasterio
import matplotlib.pyplot as plt
import numpy as np
1. Visualización y apertura de la imagen de satélite
Vamos a la biblioteca Rasterio en esta sección para acceder a la imagen de satélite proporcionada por el satellite_image_path.
El archivo de imagen se abre con el método rasterio.open() y el objeto resultante, satellite_image, representa la imagen abierta.
Para esta tarea, usé la imagen de este enlace: https://unsplash.com/photos/JiuVoQd-ZLk y la guardé en mi computadora como “satellite.jpg”.
# Open the satellite image using rasterio
satellite_image_path = 'satellite.jpg'
satellite_image = rasterio.open(satellite_image_path)
Después de abrir la imagen, la leemos como una matriz usando la función read() del objeto satellite_image. Los valores de píxel para cada banda de las imágenes de satélite se almacenan en la matriz de imágenes.
# Read the image as an array
image_array = satellite_image.read()
Para evaluar visualmente la imagen satelital, usamos la herramienta matplotlib.pyplot para generar una figura de 10×10 pulgadas.
La matriz de imágenes se muestra usando el método imshow(). La operación de transposición (1, 2, 0) se usa para reorganizar las dimensiones de la matriz de imágenes para que se ajusten al orden anticipado por imshow().
Finalmente, axis('off') oculta las etiquetas de los ejes, brindando una vista clara de la imagen del satélite.
# Visualize the image
plt.figure(figsize=(10, 10))
plt.imshow(image_array.transpose(1, 2, 0))
plt.axis('off')
plt.show()
2. Extracción de Metadatos
Extraemos información de metadatos vitales sobre la imagen satelital después de abrirla y mostrarla. Esta información nos ayuda a comprender las cualidades de la imagen y ofrece un contexto para futuras investigaciones.
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)
Usando los atributos de ancho y alto del objeto satellite_image, extraemos el ancho y el alto de la imagen. La propiedad crs se utiliza para recuperar el sistema de referencia de coordenadas (CRS) de la imagen.
El CRS brinda información sobre el sistema de referencia espacial de la imagen, lo que nos permite hacer coincidir las coordenadas de la imagen con lugares del mundo real.
Finalmente, usamos el atributo count del objeto satellite_image para calcular el número de bandas en la imagen. Estos datos son críticos para un análisis posterior porque nos permiten obtener los valores de píxel para cada banda en la matriz de imágenes.
3. Cálculo de estadísticas de banda
Calculamos estadísticas para cada banda en la matriz de imágenes en esta parte. Un ciclo itera a través de cada banda, y las funciones mínima, máxima, media y estándar de la biblioteca numpy se utilizan para calcular estas estadísticas.
Una lista de diccionarios almacena las estadísticas de cada banda.
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)
El bucle recorre cada banda, y la banda variable representa el índice de la banda. Usando image_array[band], extraemos los valores de píxeles de la matriz de imágenes para cada banda.
Luego, para la banda actual, las funciones np.min(), np.max(), np.mean() y np.std() se utilizan para determinar la desviación mínima, máxima, media y estándar del píxel. valores.
Los datos calculados para cada banda se guardan en un diccionario con claves como 'Banda', 'Min', 'Max', 'Mean' y 'Std. Cada diccionario se adjunta a la lista de estadísticas de la banda. Finalmente, los datos de cada banda se imprimen en la consola.
4. Cálculo del NDVI (índice de vegetación de diferencia normalizada)
El NDVI es una medida popular para medir la salud de las plantas. En esta sección, verificamos si la imagen incluye al menos cuatro bandas, que son necesarias para el cálculo de 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.")
Para comenzar, establecemos las variables red_band y nir_band en Ninguno. La variable image_count se usa luego para determinar si la imagen contiene al menos cuatro bandas.
Si es así, inferimos que la banda roja es el índice 2 y la banda del infrarrojo cercano (NIR) es el índice 3. Las bandas coincidentes de la matriz de imágenes se asignan a las variables red_band y nir_band.
Si tanto la banda roja como la NIR son accesibles, el NDVI se calcula mediante la fórmula (NIR – Red) / (NIR + Red). Los números NDVI que resultan indican el índice de vegetación para cada píxel de la imagen.
Luego vemos el NDVI creando una nueva figura y mostrando la matriz NDVI usando imshow(). El método colorbar() agrega una barra de colores a la gráfica, dando a los valores NDVI una referencia visual.
Para centrarnos por completo en la visualización de NDVI, también especificamos un título para el gráfico y eliminamos las etiquetas de los ejes con axis('off'). Finalmente, la trama se muestra con plt.show().
Se escribe un mensaje de error en la consola si la imagen carece de las bandas requeridas para el cálculo de NDVI (es decir, menos de cuatro bandas).
5. Cerrar la imagen de satélite
Es una buena práctica usar la función close() para cerrar el archivo de imagen satelital después de realizar el análisis y la visualización. Esto libera cualquier recurso del sistema vinculado al archivo de imagen.
satellite_image.close()
Aquí está mi solución:
¡Eso es!
Notas finales
El papel de Python para ayudar en el estudio de estos conjuntos de datos masivos se vuelve cada vez más importante a medida que aumentan la disponibilidad y la resolución de las imágenes satelitales.
La capacidad de usar Python para acceder, procesar, analizar y mostrar imágenes satelitales ofrece el camino para aplicaciones creativas y conocimientos que pueden impulsar un buen cambio y un mayor conocimiento de nuestro mundo.
Recuerde explorar la gran selección de recursos, tutoriales y bibliotecas disponibles para aumentar sus conocimientos y habilidades a medida que continúa su aventura en el análisis de imágenes satelitales con Python.
Continúe interesado, explore y use las habilidades de Python para descubrir los misterios ocultos dentro de las imágenes satelitales.
Deje un comentario