Procesamiento de imagen de imágenes satelitales

Question

¿Es posible analizar las imágenes satelitales para encontrar la posibilidad de aires de lluvia, paisajes de humedad como cuerpos de agua, áreas forestales, páramos, etc. mediante el uso de lenguajes de programación como C, C++, Java? ¿Cuál es el mejor entre estos? ¿Es complicado?

¿Hay alguna otra opción para hacer este proyecto utilizando versiones avanzadas de C, C++, Java. Estos idiomas tienen funciones especiales para leer valores de píxeles. Sin usar herramientas como MATLAB, LABVIEW.

Answer 1

alt text http://xs.to/thumb-1F0D_4B62DE2C.jpgalt text http://xs.to/thumb-0C7F_4B62DFCB.jpg

hay una sección en el libro "Digital Image Processing 3rd Edition" sobre el análisis de masa de tierra si no recuerdo mal. Consulte también "Procesamiento digital de imágenes en C", que puede descargar here.

IIRC y this NASA page seems to confirm, y no soy físico, necesitarás imágenes satallitas con el espectro electromagnético completo (no solo visible). Esto le permite elegir agua, vegetación, etc.

Landsat 7 son imágenes compuestas en color, hechas mediante la asignación de los tres principales colores a tres bandas del sensor mejorado Thematic Mapper (ETM +). Estas imágenes no son fotografías en color, son imágenes de "color falso" (los campos verdes no se verán necesariamente verdes en la imagen ).

Las bandas Landsat ayudará:

1 costera asignación del agua, la discriminación suelo/vegetación, clasificación de bosques, hecho por el hombre identificación de estructuras
2 discriminación vegetación y vigilancia de la salud, hecho por el hombre identificación de estructuras
3 identificación de especies de plantas, identificación de la característica del hombre
4 monitoreo de la humedad del suelo, monitoreo de la vegetación, discriminación corporal por agua
5 monitoreo del contenido de humedad de la vegetacióntemperatura 6 superficie, monitoreo estrés de la vegetación, el monitoreo de humedad del suelo, nube diferenciación, monitoreo volcánico
7 mineral y la discriminación de la roca, el contenido de humedad de la vegetación

Para más detalles ver: Lillesand, T. y Kiefer, R., 1994. Teledetección e interpretación de imágenes. John Wiley and Sons, Inc., Nueva York, p. 468.

Es posible que también desee crear un relieve en 3D de las imágenes y tratar de relacionar los datos del espectro con los valles, los puntos del río, las regiones costeras, etc. En resumen, hay datos para realizar estimaciones a través del análisis de imágenes

Answer 2

Los operadores de textura pueden diferenciar las regiones geográficas de las imágenes de satélite. Aquí hay un paper de Robert Haralick describiendo operadores de texturas clásicos para identificar cuerpos de agua, regiones de césped, áreas metropolitanas, etc.

He tenido cierto éxito con la caja de herramientas de código abierto Orfeo, que es una biblioteca de procesamiento de imágenes C++ basada en ITK, pero específicamente para imágenes satelitales.Puede ver algunos ejemplos de implementación de operadores de texturas en la documentación here. respuesta

Answer 3

de paniwani es un buen comienzo - en la medida en que sugiere el análisis de la textura. Imagemagick no se usa a menudo para el análisis de texturas, pero definitivamente es una herramienta posible para hacerlo. Mira esto:

$ cat get_images.sh 
#!/bin/bash 

base_url='http://maps.googleapis.com/maps/api/staticmap?center=' 
other_params='&zoom=12&size=400x400&maptype=satellite&sensor=false' 

curl -o desert1.png "$base_url"'41.660000,112.900000'"$other_params" 2>/dev/null 
curl -o desert2.png "$base_url"'40.660000,112.900000'"$other_params" 2>/dev/null 
curl -o rural1.png "$base_url"'40.714728,-74.400000'"$other_params" 2>/dev/null 
curl -o rural2.png "$base_url"'41.714728,-74.400000'"$other_params" 2>/dev/null 
curl -o suburban1.png "$base_url"'40.614728,-74.300000'"$other_params" 2>/dev/null 
curl -o suburban2.png "$base_url"'40.714728,-74.200000'"$other_params" 2>/dev/null 
curl -o urban1.png "$base_url"'40.744728,-73.831672'"$other_params" 2>/dev/null 
curl -o urban2.png "$base_url"'40.754728,-73.930672'"$other_params" 2>/dev/null 

echo -e "\nEntropy:" 
for t in "desert1" "desert2" "rural1" "rural2" "suburban1" "suburban2" "urban1" "urban2"; do 
    echo -e " " $t "\t" `./entropy "$t".png | grep Aver | sed -e 's/.*= //'` 
done 

echo -e "\nStd Dev:" 
for t in "desert1" "desert2" "rural1" "rural2" "suburban1" "suburban2" "urban1" "urban2"; do 
    echo -e " " $t "\t" `convert "$t".png -format '%[fx:standard_deviation]' info:` 
done 

echo -e "\nRatio of hi freq to low freq:" 
for t in "desert1" "desert2" "rural1" "rural2" "suburban1" "suburban2" "urban1" "urban2"; do 
    convert "$t".png -fft +depth +adjoin "$t"_fft_%d.png 
    convert "$t"_fft_1.png -fill none -stroke black -strokewidth 100 -draw "rectangle 50,50,350,350" "$t"_fft_1b.png 
    convert "$t"_fft_1.png -fill none -stroke black -strokewidth 100 -draw "rectangle 150,150,250,250" "$t"_fft_1c.png 
    lo=`./entropy "$t"_fft_1b.png | grep Average | sed -e 's/.*= //'` 
    hi=`./entropy "$t"_fft_1c.png | grep Average | sed -e 's/.*= //'` 
    echo -e " " $t "\t" `echo "scale=8; $lo/$hi" | bc` 
done 

$ ./get_images.sh 

Entropy: 
    desert1 0.557244 
    desert2 0.586651 
    rural1 0.652486 
    rural2 0.709812 
    suburban1 0.69883 
    suburban2 0.727527 
    urban1 0.746479 
    urban2 0.765279 

Std Dev: 
    desert1 0.0756219 
    desert2 0.0881424 
    rural1 0.107279 
    rural2 0.140878 
    suburban1 0.125647 
    suburban2 0.143765 
    urban1 0.150628 
    urban2 0.185245 

Ratio of hi freq to low freq: 
    desert1 .41319501 
    desert2 .41337079 
    rural1  .41333309 
    rural2  .41335422 
    suburban1 .41326120 
    suburban2 .41339882 
    urban1  .41327271 
    urban2  .41326168 

Esos tres parámetros diferentes (entropía de la imagen, la imagen de la desviación estándar, coeficiente de frec alta al contenido frec lo en una imagen) están bastante bien correlacionada con un espectro que va desde el desierto-a-campo a la -ububano a urbano. Si los coloca en un clasificador (por ejemplo, una red neuronal), apuesto a que podría desarrollar un predictor decente de si una imagen de satélite de mapa de Google es tierra desierta, rural, suburbana o urbana.

Answer 4

Recomendaría Python para esto ya que el lenguaje, en mi experiencia, es más fácil de usar y hay un número creciente de módulos de python para procesar datos detectados remotamente. Además, python es de código abierto, por lo que puede evitar MATLAB, etc.

El software RSGISLib tiene enlaces de python y es ideal para procesar datos de detección remota. Lo utilicé por completo a lo largo de mi doctorado. El software se puede encontrar aquí http://www.rsgislib.org y un gran blog que muestra sus aplicaciones se puede encontrar aquí https://spectraldifferences.wordpress.com

Tengo experiencia en Geografía pero pude usar Python con facilidad. C++ y JAVA, etc. son más complicados en mi opinión, ya que Python a menudo tiene módulos que hacen las partes difíciles (accediendo a imágenes, verificando proyecciones, etc.) por usted.