A vixilancia ambiental, a agricultura, a planificación urbana, a xestión de desastres e os estudos sobre o cambio climático beneficiáronse da análise de imaxes de satélite.
Podemos adquirir coñecementos significativos sobre as características, os cambios e a dinámica do noso planeta explotando a enorme cantidade de datos rexistrados polos satélites de observación da Terra.
Python, unha linguaxe de programación versátil e forte, ofrece un rico ecosistema de bibliotecas e ferramentas para un procesamento rápido e eficaz de imaxes de satélite.
O uso de análise de imaxes de satélite abre un mundo de posibilidades. Permítenos extraer información útil de fotos de satélite, como a categorización da cobertura terrestre, a avaliación da saúde da vexetación, o seguimento da expansión urbana e o mapeo da costa.
Podemos procesar, mostrar e analizar imaxes de satélite facilmente aproveitando a versatilidade de Python e módulos como rasterio, numpy e matplotlib.
Un dos principais beneficios do uso de Python para a análise de imaxes de satélite é a súa ampla gama de módulos de procesamento de datos xeoespaciais.
Rasterio, por exemplo, ten unha interface sinxela para ler e modificar a información ráster, polo que é adecuada para traballar con ficheiros de imaxes de satélite.
O módulo numpy ofrece operacións de matriz sofisticadas para realizar cálculos rápidos e estatísticas sobre datos de imaxes. Matplotlib tamén nos permite xerar imaxes relevantes para axudar na interpretación e comunicación dos resultados analíticos.
Nas seguintes seccións, veremos exemplos reais e fragmentos de código para mostrar como se pode usar Python para analizar fotos de satélite.
Explicaremos como abrir fotos de satélite, visualizar datos de imaxes, extraer metadatos, calcular estatísticas de bandas e realizar análises particulares como o Índice de Vexetación de Diferencia Normalizada (NDVI).
Estes exemplos axudarano a comezar no intrigante tema da análise de imaxes de satélite con Python.
En primeiro lugar, necesitamos importar algunhas bibliotecas para axudarnos coa nosa tarefa.
import rasterio
import matplotlib.pyplot as plt
import numpy as np
1. Visualización e apertura da imaxe de satélite
Faremos a biblioteca Rasterio nesta sección para acceder á imaxe de satélite que nos proporciona o camiño_imaxe_satélite.
O ficheiro de imaxe ábrese mediante o método rasterio.open() e o obxecto resultante, satellite_image, representa a imaxe aberta.
Para esta tarefa, usei a imaxe desta ligazón: https://unsplash.com/photos/JiuVoQd-ZLk e gardeina no meu ordenador como "satellite.jpg".
# Open the satellite image using rasterio
satellite_image_path = 'satellite.jpg'
satellite_image = rasterio.open(satellite_image_path)
Despois de abrir a imaxe, lemos como unha matriz usando a función read() do obxecto satellite_image. Os valores de píxeles para cada banda das imaxes de satélite gárdanse na matriz de imaxes.
# Read the image as an array
image_array = satellite_image.read()
Para avaliar visualmente a imaxe do satélite, usamos a ferramenta matplotlib.pyplot para xerar unha figura de 10×10 polgadas.
A matriz de imaxes móstrase mediante o método imshow(). A operación de transposición (1, 2, 0) úsase para reorganizar as dimensións da matriz de imaxes para que se axusten á orde prevista por imshow().
Finalmente, axis('off') oculta as etiquetas dos eixes, dándolle unha visión clara da imaxe do 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 vitais sobre a imaxe do satélite despois de abrila e mostrala. Esta información axúdanos a comprender as calidades da imaxe e ofrece contexto para futuras investigacións.
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 os atributos width e height do obxecto satellite_image, extraemos o ancho e a altura da imaxe. A propiedade crs úsase para recuperar o sistema de referencia de coordenadas (CRS) da imaxe.
O CRS dá información sobre o sistema de referencia espacial da imaxe, o que nos permite relacionar as coordenadas da imaxe con lugares do mundo real.
Finalmente, usamos o atributo count do obxecto satellite_image para calcular o número de bandas da imaxe. Estes datos son críticos para a análise posterior porque nos permiten obter os valores de píxeles para cada banda da matriz de imaxes.
3. Cálculo de estatísticas de bandas
Calculamos estatísticas para cada banda na matriz de imaxes nesta parte. Un bucle itera en cada banda e as funcións min, max, mean e std da biblioteca numpy úsanse para calcular estas estatísticas.
Unha lista de dicionarios almacena as estatí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)
O bucle pasa por cada banda, representando a banda variable o índice de banda. Usando image_array[band], extraemos os valores de píxeles da matriz de imaxes para cada banda.
Entón, para a banda actual, utilízanse as funcións np.min(), np.max(), np.mean() e np.std() para determinar o mínimo, o máximo, a media e a desviación estándar do píxel. valores.
Os datos calculados para cada banda gárdanse nun dicionario con teclas como "Band", "Min", "Max", "Mean" e "Std. Cada dicionario engádese á lista de estatísticas de banda. Finalmente, os datos de cada banda son impresos na consola.
4. Cálculo do NDVI (Índice de Vexetación de Diferencia Normalizada).
O NDVI é unha medida popular para medir a saúde das plantas. Nesta sección, comprobamos se a imaxe inclúe polo menos catro bandas, que son necesarias para o cálculo 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 comezar, configuramos as variables red_band e nir_band en None. A variable image_count úsase entón para determinar se a imaxe contén polo menos catro bandas.
Se é así, deducimos que a banda vermella é o índice 2 e a banda do infravermello próximo (NIR) é o índice 3. As bandas coincidentes da matriz de imaxes asígnanse ás variables red_band e nir_band.
Se as bandas vermellas e NIR son accesibles, o NDVI calcúlase mediante a fórmula (NIR – Vermello) / (NIR + Vermello). Os números NDVI que resultan indican o índice de vexetación para cada píxel da imaxe.
Despois vemos o NDVI creando unha nova figura e mostrando a matriz NDVI usando imshow(). O método colorbar() engade unha barra de cores á trama, dándolle aos valores NDVI unha referencia visual.
Para centrarnos por completo na pantalla NDVI, especificamos ademais un título para a trama e eliminamos as etiquetas dos eixes con axis('off'). Finalmente, a trama móstrase con plt.show().
Escríbese unha mensaxe de erro na consola se a imaxe carece das bandas necesarias para o cálculo NDVI (é dicir, menos de catro bandas).
5. Achegando a imaxe de satélite
A mellor práctica é usar a función close() para pechar o ficheiro de imaxe do satélite despois de realizar a análise e visualización. Isto libera calquera recurso do sistema ligado ao ficheiro de imaxe.
satellite_image.close()
Aquí está a miña solución:
É iso mesmo!
Notas finais
O papel de Python para axudar ao estudo destes conxuntos de datos masivos é cada vez máis importante a medida que aumenta a dispoñibilidade e resolución das imaxes de satélite.
A capacidade de usar Python para acceder, procesar, analizar e mostrar imaxes de satélite ofrece o camiño para aplicacións creativas e coñecementos que poden impulsar un bo cambio e un maior coñecemento do noso mundo.
Lembra explorar a gran selección de recursos, tutoriais e bibliotecas dispoñibles para aumentar os teus coñecementos e habilidades mentres continúas na túa aventura na análise de imaxes de satélite usando Python.
Continúa interesándose, explora e utiliza as habilidades de Python para descubrir os misterios enterrados dentro das imaxes de satélite.
Deixe unha resposta