Tesis - DSpace@UCLV - "Marta Abreu" de Las Villas

Universidad Central “Marta Abreu” de Las Villas
Facultad Matemática, Física y Computación
Licenciatura en Ciencia de la Computación
Trabajo de Diploma
Diseño e implementación de herramientas para el soporte de
archivos de formatos de datos científicos en SIG
Autor: Maikel F. Carmona Zayas
Tutor: MSc. Romel Vázquez Rodríguez
Santa Clara
2013
Hago constar que el siguiente trabajo fue realizado en la Universidad “Martha Abreu” de Las Villas
como parte de la culminación de mis estudios en la especialidad de Ciencias de la Computación,
autorizando que el mismo sea utilizado por la institución, en los fines que esta estime conveniente, tanto
de forma parcial como total y además no podrá ser presentado en eventos ni publicados sin el
consentimiento del centro de altos estudios.
Firma del autor
Los abajo firmantes, certificamos que el siguiente trabajo ha sido realizado según los acuerdos
establecidos por la dirección de nuestro centro y el mismo cumple con los requisitos de un trabajo de tal
envergadura referido a la temática señalada.
Firma del Tutor
Firma del Jefe de Grupo Investigación
I
Estar preparado es importante, saber esperar lo es aún más, pero aprovechar el
momento adecuado es la clave de la vida.
Arthur Schnitzler (1862-1931)
II
Dedicatoria
A mi mamá y mi papá
A mis abuelos
A mi hermanita
A todos mis tíos y primos
A todas mis amistades
A todas las personas que siempre creyeron en mí
A todas las personas que contribuyeron en mi formación personal y profesional
III
Agradecimientos
A mi madre por haber sido incondicional conmigo en estos tiempos, por haberme dado la
vida y todo el amor del mundo.
A mi padre por ser siempre un ejemplo para mí, por darme todo y ayudarme a
convertirme en la persona que soy.
A mis a abuelos Mima y Papi que aunque ya no están físicamente, siempre estarán
conmigo por ser también padres para mí.
A mi hermanita Meilan cuyos besos y abrazos son siempre capaces de alegrar los días
más lúgubres.
A mis tíos y primos que siempre se preocuparon por mí y me apoyaron cuando los
necesité.
A mis amigos y compañeros de la vida que junto a ellos compartí grandes momentos.
A mi tutor Romel Vázquez por su preocupación y su constancia.
Al grupo de Computación Gráfica por haberme demostrado que todos son mis amigos.
A Alexis por ayudarme cuando más lo necesitaba y demostrar ser una gran persona.
A mis profes que me impartieron con gran amor y dedicación todos los conocimientos
necesarios.
Maikel F. Carmona Zayas.
IV
Resumen
RESUMEN
La integración de técnicas de Visualización Científica en Sistemas de Información Geográfica es una
alternativa novedosa para el análisis visual de datos científicos. Dotar a los Sistemas de Información
Geográfica con tales herramientas contribuye a la comprensión y análisis de grandes conjuntos de datos
con una baja densidad espacial y permite encontrar correlaciones entre las variables en el tiempo y el
espacio. En esta investigación se presenta una herramienta para el trabajo con archivos de datos
científicos al Sistema de Información Geográfica gvSIG. Esta herramienta es implementada como un
módulo de gvSIG y contiene varias funciones para el manejo y transformación de los datos con archivos
HDF. En el trabajo se presentan las principales características de las disciplinas involucradas como la
Visualización Científica y los Sistemas de Información Geográfica, así como su integración. Los
principales aspectos relacionados con el diseño e implementación de la herramienta son explicados con
el objetivo de poder agregar nuevas funcionalidades a dicha extensión en el futuro. Se desarrolla un
manual de usuario que muestra el uso del sistema. Es una herramienta de propósito general por lo que
permite su utilización en múltiples campos de aplicación.
V
Abstract
ABSTRACT
The integration of Scientific Visualization techniques into Geographic Information Systems is an
innovative alternative for the visual analysis of scientific data. Providing Geographic Information
Systems with such tools improves the analysis and understanding of datasets with very low spatial
density and allows finding correlations between variables in time and space. In this research a tool for
the work with archives of scientific data for gvSIG Geographic Information Systems is presented. This
tool is implemented as gvSIG's module and it contains several functions for handling and transformation
of the data with archives HDF. This work presents the main features of the implicated disciplines as the
Scientific Visualization and Geographic Information Systems, as well as its integration. The main
aspects related with the design and implementation of the tool are explained, in order to add new
functionalities to this extension in the future. User’s manual is developed that show the use of the
system. It is a general-purpose tool, so it allows their use in multiple application fields.
VI
Índice
Contenido
Introducción ................................................................................................................................................ 1
Antecedentes ........................................................................................................................................... 3
Problemática ........................................................................................................................................... 3
Objetivo general ...................................................................................................................................... 4
Objetivos Específicos.............................................................................................................................. 4
Hipótesis ................................................................................................................................................. 4
Justificación de la investigación ............................................................................................................. 4
Capítulo 1. Formatos de datos científicos utilizados en la Visualización Científica y sistemas de
información geográficos ............................................................................................................................. 5
1.1
Formatos de datos científicos utilizados en la Visualización Científica ...................................... 5
1.1.1
Hierarchical Data Format ...................................................................................................... 5
1.1.2
HDF-EOS .............................................................................................................................. 7
1.1.3
The Network Common Data Form ....................................................................................... 8
1.1.4
FITS .................................................................................................................................... 10
1.2
Sistemas de Información Geográficos, propietarios y libres ...................................................... 12
1.2.1
ARCGIS .............................................................................................................................. 14
1.2.2
GvSIG ................................................................................................................................. 17
1.2.3
GRASS................................................................................................................................ 18
1.2.4
El proyecto SEXTANTE .................................................................................................... 18
1.3
Integración de la Visualización Científica y los Sistemas de Información Geográficos ........... 22
1.3.1
Ejemplos de integración ...................................................................................................... 23
1.3.2
Integración de SIG con formatos de datos científicos, ARCGIS-NetCDF, ARCGIS-HDF24
1.4
Conclusiones Parciales ............................................................................................................... 26
Capítulo 2. Módulo de manipulación de archivos HDF en gvSIG ........................................................... 27
2.1
Diseño de la extensión realizada a gvSIG .................................................................................. 27
2.2
Concepciones importantes en la implementación de la extensión ............................................. 32
2.2.1
2.3
Forma general de crear algoritmos en Sextante .................................................................. 33
Explicación de las principales funcionalidades del módulo....................................................... 33
VII
Índice
2.4
Principales métodos de la clase manipuladora ........................................................................... 46
2.5
Conclusiones parciales ............................................................................................................... 52
Capítulo 3. Presentación de los resultados ................................................................................................ 54
3.1
Manual de usuario ...................................................................................................................... 54
3.2
Caso de Estudio .......................................................................................................................... 58
3.3
Conclusiones parciales ............................................................................................................... 61
Conclusiones ............................................................................................................................................. 62
Recomendaciones ..................................................................................................................................... 63
Bibliografía ............................................................................................................................................... 64
VIII
Introducción
Introducción
En el ámbito científico, se genera gran cantidad de información en formato digital, que es necesario
distribuir y dada la diferente naturaleza de ésta, es necesario utilizar distintos formatos especialmente
adaptados a cada uno de los tipos de datos que se vayan a almacenar. El principal problema, radica en la
estandarización y la interoperabilidad, ya que, pese a que existen diversos estándares de almacenamiento
de información, no todos son soportados por las distintas aplicaciones informáticas utilizadas, lo que
puede presentar problemas en el momento de la difusión y reutilización de dicha información.
Con el fin de dar respuesta a las necesidades de almacenamiento y difusión de datos científicos de
diversa naturaleza, en un formato flexible e independiente de la plataforma, comenzó a desarrollarse el
formato HDF en los laboratorios de la NCSA (National Center for Supercomputing Applications) a
partir del año 1988, siendo soportado en la actualidad por el HDF Group, dependiente de la Universidad
de Illinois. HDF es una biblioteca y un formato de fichero multi-objeto para la transferencia de datos
gráficos y numéricos entre máquinas. Este formato representa una alternativa eficaz al ser adaptado
como estructura de almacenamiento de datos (Ullman and Denning, 2012).
Actualmente, este formato se utiliza por múltiples organismos, tantos públicos como privados, para la
difusión de sus datos y resultados, entre las que se encuentra la NASA, la Agencia Europea del Espacio
(ESA), que los aplican en datos procedentes de los sensores MODIS, MERIS o ETM+, entre otros.
Visualizar es representar de manera gráfica un fenómeno, ya sea estático (como por ejemplo, con una
gráfica de barras) o dinámicamente, (por ejemplo, el cubo de Rubick, que fue ideado para representar las
soluciones a problemas espaciales) haciendo uso de medios artificiales para representar uno o más
comportamientos. En forma estricta, visualizar es crear una representación visible de algo, ya sea un
concepto, idea, un grupo de datos o de algún objeto que por pequeño, enorme o distante, no lo podemos
abarcar o alcanzar a ver por métodos comunes. En la computación y el diseño con fines de ingeniería el
término visualización tiene un significado mucho más específico, entendiéndose como la transformación
y posterior representación de datos científicos y conceptos abstractos, en imágenes. La VisCi
(Visualización Científica) según (MORELL and PÉREZ, 2006) significa encontrar una representación
visual apropiada para un conjunto de datos que permita mayor efectividad en el análisis y evaluación de
los mismos. Según (Rhyne, 1997a) permite la transformación de los datos numéricos o simbólicos y la
1
Introducción
información en imágenes geométricas generadas por computadora. Es una metodología para interpretar,
a través de una imagen en la computadora, tanto datos de mediciones como los generados por modelos
computacionales. La investigación y el desarrollo de la VisCi se han centrado en cuestiones relacionadas
con el renderizado de gráficos en tres dimensiones, animaciones de series temporales y visualización
interactiva en tiempo real.
Se estima que el 50% de las neuronas está dedicado a la visión, además, la densidad de información por
unidad de área es notablemente mayor a la de un texto. Por otro lado, la visualización nos permite ver lo
que “no es posible ver directamente”, nos posibilita reconocer patrones de comportamiento de los datos,
ver en una sola imagen o en una secuencia de imágenes (animación) una gran cantidad de datos y nos
facilita la comprensión de algunos conceptos, sobre todo de tipo abstracto.
Por ejemplo, si se diera el caso de que tuviéramos una serie de datos, obtenidos de una estación
meteorológica, al mostrar la tabla no se distingue alguna relación entre los datos, al hacer una gráfica de
los valores vemos que siguen cierto patrón de comportamiento. Entre sus ventajas, está el poder
representar datos de varias dimensiones o variables, lográndose por algunos métodos representar cuatro
o más variables al mismo tiempo. Por ejemplo, el plano cartesiano puede mostrar dos variables, si
agregamos otro plano, podremos ver 3 variables o dimensiones, si agregamos colores, tendremos 4
variables, si se hace alguna animación de la gráfica podremos apreciar una quinta variable. Otra gran
ventaja es la independencia del lenguaje, ya que la idea principal del problema está representada de
forma gráfica.En los últimos años, los avances en la tecnología han facilitado la obtención de grandes
cantidades de información.Para el análisis de estos datos es necesario el uso de técnicas avanzadas
debido a que no pueden ser analizados suficientemente bien en forma numérica. La visualización
científica (VC) significa encontrar una representación visual apropiada para un conjunto de datos, dado
que permita mayor efectividad en el análisis y evaluación de los mismos. Simplifica el análisis,
comprensión y la comunicación de modelos, conceptos y datos en la ciencia y la ingeniería.
Mediante imágenes de satélite, estaciones de medición de alta precisión, o cualquier otra fuente de este
tipo, se generan a diario volúmenes de datos muy grandes y complejos. De todos los datos generados por
entes especializados, solo una cuarta parte se almacena, y de éstos solo una cuarta parte realmente se
analiza. Como se puede ver se pierden datos valiosos. De muchas informaciones importantes, solamente
se utiliza un pequeño porcentaje. Entonces surge la necesidad de nuevos métodos de análisis para
examinar estos datos de forma efectiva y extraer de ellos información y conocimientos. Paralelo al
2
Introducción
desarrollo de la Visualización Científica se ha ido incrementando el desarrollo de los Sistemas de
Información Geográfica (SIG).
Un SIG es una integración organizada de hardware, software y datos geográficos diseñado para capturar,
almacenar, manipular, analizar y desplegar en todas sus formas la información geográficamente
referenciada, con el fin de resolver problemas complejos de planificación y gestión. En un sentido más
genérico, los SIG son herramientas que permiten a los usuarios crear consultas interactivas, analizar la
información espacial, editar datos, mapas y presentar los resultados de todas estas operaciones (Bolstad,
2005). El uso de Sistemas de Información Geográfica (SIG) ha llegado a ser esencial en todos los
campos relacionados con la geografía y el medio ambiente, pasando por las aplicaciones más clásicas de
cartografía, urbanismo y gestión de recursos. Actualmente se utilizan los SIG para resolver problemas
tan diversos como la planificación de la extinción de incendios, el análisis de riesgos ambientales o la
propagación de contaminantes.
La presente investigación se enmarca en la integración de un módulo para el soporte de archivos HDF
en gvSIG. Las soluciones están dadas en el área del software libre, facilitando la reutilización de las
aplicaciones desarrolladas.
Antecedentes
Este trabajo tiene como antecedentes el proyecto desarrollado en conjunto por el grupo de Computación
Gráfica de nuestra universidad y el grupo gvSIG de Valencia, con el objetivo de lograr un SIG libre para
el uso de la comunidad internacional. No podemos dejar de mencionar trabajos como el realizado por el
Licenciado en Ciencias de la Computación Alexis Fajardo Moya, Visualización de datos
multiparamétricos en Sistemas de Información Geográfica, donde se comenzó a integrar nuestro trabajo
a gvSIG logrando así una estrecha colaboración entre ambos lados y luego, el efectuado por el
Licenciado Leonel Díaz Gómez, Módulo para el trabajo con archivos HDF en el Sistema de
Información Geográfica gvSIG.
Problemática
Los formatos de datos científicos son muy útiles para almacenar y manipular grandes cantidades de
datos, que se puedan analizar mediante técnicas de visualización científica. Se hace necesario la
incorporación de estas capacidades a los SIG libres para aumentar su potencial e integración con
técnicas de Visualización Científica.
3
Introducción
Objetivo general
Desarrollar herramientas para un SIG que permita la manipulación y el trabajo con archivos de formatos
de datos científicos.
Objetivos Específicos
 Analizar los principales formatos de datos científicos y los SIG disponibles.
 Determinar un formato de datos científico y un SIG adecuado para integrar sus principales
funcionalidades.
 Implementar herramientas que permitan el trabajo con formatos de datos científicos para un SIG.
Hipótesis
La integración de los formatos de datos científicos más utilizados en la VisCi con los SIG constituye una
poderosa herramienta para los investigadores que trabajan en las fronteras de estas dos disciplinas. El
desarrollo de herramientas para gvSIG que permita el trabajo con archivos HDF pone de manifiesto las
ventajas de esta integración.
Justificación de la investigación
Nuestro Centro de Estudios Informáticos cuenta con el personal capacitado, con la tecnología necesaria
y además la necesidad de desarrollar un SIG de software libre que presente este tipo de funcionalidades
para el trabajo con datos científicos.
4
Capítulo 1
Capítulo 1. Formatos de datos científicos utilizados en la Visualización
Científica y sistemas de información geográficos
En el presente capítulo se tratan las generalidades de los principales formatos de datos científicos
utilizados en la Visualización Científica, se abordan las principales características de los SIG, así como
una descripción de los más utilizados en el mundo, ya sea software libre o propietario. Además, se
brindan elementos que evidencian la integración de la VisCi con los SIG.
1.1 Formatos de datos científicos utilizados en la Visualización Científica
A continuación se describen los principales formatos de datos utilizados en la visualización científica,
algunos de estos de gran complejidad pero de una amplia gama de utilidades a la hora de realizar el
proceso de visualización.
1.1.1 Hierarchical Data Format
Hierarchical Data Format, más conocido por HDF, es desarrollado por el Centro Nacional de
Aplicaciones de Supercómputo (National Center for Supercomputing Applications, NCSA) en la
Universidad de Illinois. Es una biblioteca y un formato de fichero multi-objeto para la transferencia de
datos gráficos y numéricos entre máquinas (Ullman and Denning, 2012).
HDF se encuentra disponible de forma gratis. La distribución consiste en la biblioteca HDF, las
utilidades de línea de comando HDF y una suite de prueba (código fuente solamente).
HDF presenta 4 niveles de interacción. En su nivel más bajo es un formato de fichero físico para el
almacenamiento de datos científicos. En su nivel más alto es una colección de utilidades y aplicaciones
para manipular, ver y analizar datos en los ficheros HDF, y entre esos niveles HDF, una biblioteca de
programas que provee APIs de alto nivel y una interfaz de datos de bajo nivel (Figura 1).
5
Capítulo 1
Figura 1. Niveles de interacción de HDF
Aplicaciones generales
En el nivel más alto hay utilidades de línea de comandos de HDF, aplicaciones de NCSA que soportan
visualización de datos y análisis, y variedad de aplicaciones de terceros desarrolladores.
Existen utilidades de línea de comandos de HDF para:
 Convertir de un formato a otro (por ejemplo, desde y hacia JPEG/HDF)
 Analizar y ver ficheros HDF (siendo hdp una de las herramientas más útiles)
 Manipular los ficheros HDF
De las utilidades HDF, la “hdp” es una de las más importantes, su función está dada en que provee
información rápida sobre los contenidos y objetos de datos en un fichero HDF (Long et al., 2013), puede
listar los contenidos de los ficheros HDF en varios niveles con diferentes detalles, además puede
también vaciar los datos de uno o más ficheros en el fichero, en formato binario o ASCII.
Compresión de datos
HDF 4.0 (y versiones posteriores) soportan una interfaz de compresión de bajo nivel, la cual permite que
cualquier objeto de dato sea comprimido utilizando una variedad de algoritmos. Actualmente solo tres
algoritmos de compresión están soportados: Run-length Encoding (RLE), Huffman adaptativo, y un
codificador de diccionario LZ-77 (el algoritmo de decodificación de gzip) (Yeh et al., 2002). Los planes
para algoritmos futuros incluyen un codificador de diccionario Lempel/Ziv-78, un codificador aritmético
y un algoritmo rápido de Huffman. HDF 4.0 (y entregas posteriores) soportan compresión de n-bit para
SDS, RLE (Run- Length Encoding), IMCOMP, y compresión JPEG para imágenes de puntos.
6
Capítulo 1
El fichero HDF
Un fichero HDF contiene un encabezamiento de fichero, al menos un bloque descriptor de datos, y cero
o más elementos de datos. El encabezamiento de fichero identifica el fichero como un fichero HDF. Un
bloque descriptor de datos contiene un número de descriptores de datos. Un descriptor de datos y un
elemento de dato juntos, conforman un objeto de dato, el cual es la estructura básica de agrupamiento
para el encapsulamiento de datos en un fichero HDF.
El fichero HDF posee una serie de rasgos que se mencionan a continuación:

Es versátil. HDF soporta muchos tipos diferentes de modelos de datos. Cada modelo de dato
define un conjunto específico de tipo de dato y provee una API para lectura, escritura y
organización de datos y metadatos del tipo correspondiente. Los modelos de datos soportados
incluyen arreglos multidimensionales, imágenes de puntos, y tablas (Poinot, 2010).

Es auto-descriptivo, permitiendo una aplicación para interpretar la estructura y contenidos de un
fichero sin ninguna información proveniente del exterior (Poinot, 2010).

Es flexible. Con HDF se pueden mezclar y asociar objetos relacionados, agrupados en un fichero
y acceder a ellos como un grupo o como objetos individuales. Los usuarios pueden además crear
sus propias estructuras de agrupamiento utilizando un rasgo de HDF llamado vgroups (Poinot,
2010).

Es extensible. Puede acomodar fácilmente nuevos modelos de datos, sin tener en cuenta si fueron
adicionados por el equipo de desarrolladores de HDF o por los usuarios de HDF (Poinot, 2010).

Es portable. Los ficheros HDF pueden ser compartidos a través de la mayoría de las plataformas
comunes, incluyendo muchas estaciones de trabajo y computadoras de alto desempeño. Un
fichero HDF creado en una computadora puede ser leído en un sistema diferente sin
modificación alguna(Poinot, 2010).
1.1.2 HDF-EOS
Hierarchical Data Format (HDF) es el formato de datos estándar para todos los productos de datos de la
NASA Earth Observing System (EOS). HDF es un formato de archivo de varios objetos desarrollado
por el Grupo HDF.
El Grupo HDF desarrolló HDF para ayudar a los usuarios en la transferencia y manipulación de datos
científicos a través de diversos sistemas operativos y plataformas de ordenador, usando FORTRAN y C
7
Capítulo 1
llamando a las interfaces y los servicios públicos. HDF soporta una variedad de tipos de datos: arreglos
n-dimensionales de datos científicas, tablas, anotaciones de texto, varios tipos de imágenes ráster y sus
paletas de colores asociados y metadatos. La biblioteca contiene interfaces de HDF para almacenar y
recuperar estos tipos de datos en formatos comprimidos o sin comprimir.
Para cada objeto de datos en un archivo de HDF, etiquetas predefinidas identifican el tipo, la cantidad y
las dimensiones de los datos, y la ubicación del archivo de objetos diversos. La capacidad de autodescripción de archivos HDF ayuda a los usuarios a entender completamente la estructura del archivo y
el contenido de la información almacenada en el propio archivo. Un programa interpreta y se identifican
los tipos de etiquetas en un archivo HDF y procesa los datos correspondientes. Un archivo HDF único
también puede acomodar diferentes tipos de datos, tales como datos simbólicos, numérico y gráfico, sin
embargo, las imágenes de trama y matrices multidimensionales a menudo no están geolocalizados.
Debido a que muchos datos de ciencias terrestres estructuras necesitan ser geolocalizados, el grupo HDF
desarrolló el formato HDF-EOS con los convenios adicionales y tipos de datos para los archivos HDF.
HDF-EOS es compatible con tres tipos de datos geoespaciales: la red, el punto y barrido,
proporcionando un acceso uniforme a los diversos tipos de datos en un contexto geoespacial. La
biblioteca HDF-EOS software permite a un usuario consulta o subconjunto del contenido de un archivo
de coordenadas de tierra y de tiempo si existe una dimensión espacial en los datos. Herramientas que
procesan los archivos estándar de HDF también leen archivos HDF-EOS, sin embargo, las llamadas de
la biblioteca estándar de HDF no puede acceder a los datos de geolocalización, datos de tiempo y
metadatos producto tan fácilmente como con llamadas a bibliotecas HDF-EOS.
1.1.3 The Network Common Data Form
The Network Common Data Form o netCDF, es una interfaz a una biblioteca de funciones de acceso a
datos diseñada para el almacenamiento y recuperación de datos en forma de arreglos, donde cada arreglo
es una estructura rectangular n-dimensional (con n  0,1,2 ) en la que todos sus elementos son del
mismo tipo de dato (ejemplo: caracteres de 8-bit, entero de 32-bit) y un escalar (un solo valor) equivale
a un arreglo 0-dimensional.
La biblioteca netCDF implementa un tipo de datos abstracto, por lo que todas las operaciones para
acceder y manipular datos en un conjunto de datos de netCDF, deben usar sólo las funciones que provee
la interfaz. La representación de los datos está oculta para aplicaciones que usen la interfaz, así que la
8
Capítulo 1
forma en la cual estos se encuentran almacenados puede ser cambiada sin afectar los programas
existentes. La representación física de los datos de formato netCDF está diseñada para ser independiente
de la computadora en que se almacenen.
Los datos son vistos como una colección de objetos portables y auto-descriptibles que pueden ser
accedidos a través una simple interfaz. Se puede acceder directamente a sus valores, sin conocer detalles
sobre la forma en que se encuentran almacenados. Las informaciones auxiliares sobre los datos, tales
como, las Units que utilizaron, se pueden almacenar conjuntamente con los datos. Las Utilidades
Genéricas (Genericutilities) y los programas de aplicación pueden acceder a conjuntos de datos en
netCDF y transformar, combinar, analizar o mostrar campos específicos de los datos. El desarrollo de
tales aplicaciones ha dado lugar a una mejor accesibilidad de datos y una mejor reutilización de software
para la administración, análisis y visualización de datos orientados a arreglos. La biblioteca netCDF está
soportada para varios sistemas operativos UNIX y tiene también disponible un puerto de Microsoft
Windows. El programa fue también portado hacia otros sistemas operativos y probado en los mismos,
asistidos por usuarios con acceso a esos sistemas, antes de cualquier lanzamiento mayor.
Desempeño
Una de las metas de netCDF es soportar acceso eficiente a pequeños subconjuntos de grandes conjuntos
de datos. Para lograr esto, netCDF utiliza accesos directos en lugar de accesos secuenciales. Esto puede
ser mucho más eficiente cuando el orden en que los datos son leídos es diferente del orden en que fueron
escritos, o cuando debe ser leído en diferentes órdenes para distintas aplicaciones.
La cantidad de costo para la representación externa portable depende de muchos factores, incluyendo el
tipo de dato, el tipo de computadora, la granularidad del acceso a datos, y de cuán bien se ha ajustado la
implementación a la computadora en la que está corriendo. Este costo es típicamente pequeño en
comparación con todo el conjunto de recursos utilizados por una aplicación. De cualquier forma, el
costo de la capa de representación externa es, usualmente, un precio razonable a pagar por acceso de
datos portables.
A pesar de que la eficiencia en el acceso a datos ha sido un asunto importante en el diseño e
implementación de netCDF, todavía es posible utilizar la interfaz netCDF para acceder a datos de
formas ineficientes: por ejemplo, mediante la petición de una porción de datos que requiere un sólo
valor de cada registro.
9
Capítulo 1
Partes de un fichero netCDF
Un conjunto de datos de netCDF clásico o de desplazamiento de 64 bit es almacenado como un sólo
fichero que consiste en dos partes:
 Un encabezado (header), conteniendo toda la información sobre las dimensiones, atributos y
variables, excepto para los datos de variable.
 Una parte de datos, que comprende los datos de tamaño fijo (datos para variables que no poseen
una dimensión ilimitada) y los datos de tamaño variable (datos para variables que presentan una
dimensión ilimitada).
El encabezado, al principio del fichero, contiene información sobre las dimensiones, variables, y
atributos en el fichero, incluyendo sus nombres, tipos, y otras características. La información sobre cada
variable incluye el desplazamiento al inicio de los datos de la variable para variables de tamaño fijo, o el
desplazamiento relativo de otras variables dentro de un registro. El encabezado también contiene
longitudes de dimensión e información necesaria para trasladar (map) índices multidimensionales de
cada variable hacia los desplazamientos apropiados dentro del fichero.
Las partes de datos con tamaño fijo que siguen al encabezamiento contienen todos los datos de variables
para las variables que no presentan una dimensión ilimitada. Los datos para cada variable son
almacenados contiguamente en esta parte del fichero. Si no hay variables con dimensión ilimitada, esta
es la última parte del fichero netCDF.
La parte de datos de registro que le sigue a los datos de tamaño fijo consiste en un número variable de
registros de tamaño fijo, que cada uno contiene datos para todas las variables de tipo registro. Los datos
registro para cada variable son almacenados contiguamente en cada registro.
El orden en que aparecen los datos de la variable en cada sección de datos, es el mismo en que fueron
definidas: un orden numérico incremental por el ID de variable de netCDF. Este conocimiento puede ser
utilizado a veces para mejorar el desempeño de acceso a datos, puesto que el mejor acceso a datos es
actualmente logrado mediante la lectura y escritura de datos en orden secuencial.
1.1.4 FITS
FITS o Flexible Image Transport System es el formato de archivo más utilizado comúnmente en el
mundo de la astronomía, es a menudo utilizado para almacenar también datos que no son imágenes,
como espectros electromagnéticos, listas de fotones, cubos de datos y muchos más. Un fichero FITS
10
Capítulo 1
podría contener varias extensiones, y cada una de ellas podría contener datos de un objeto. Por ejemplo,
es posible almacenar imágenes de rayos X y también imágenes pertenecientes al infrarrojo en el mismo
archivo FITS.
La mayor ventaja de FITS para datos científicos es que la información de las cabeceras es legible en
ASCII, de modo que un usuario puede examinar las cabeceras para investigar un archivo de procedencia
desconocida. Cada archivo FITS consiste en una o más cabeceras que contienen secuencias de 80
cadenas de caracteres fijos que llevan pares de valores, interpolados entre los bloques de datos. Los
pares de valores proveen información (metadatos) como son el tamaño, origen, formato binario de los
datos, comentarios, historia de los datos y cualquier otra información que el creador desee.
Imágenes
El más joven y quizás más usado tipo de datos en FITS es una imagen con una cabecera o bloque de
datos. El término "imagen" es aplicado con cierta libertad, puesto que el formato soporta matrices de
dimensiones arbitrarias -- una imagen con datos normales normalmente está en 2-D o 3-D (con la tercera
dimensión se representa el plano de color). Los datos pueden encontrarse en otros formatos como los
enteros o de punto flotante, siendo especificados en las cabeceras.
Las cabeceras de una imagen FITS pueden contener información acerca de uno o más sistemas de
coordenadas que cubren la imagen por sí misma. Las imágenes contienen un sistema implícito de
coordenadas cartesiano que describe la localización de cada pixel en la imagen, pero los usos científicos
requieren que se trabaje con un sistema de coordenadas mundial. Como FITS se ha ido generalizando
desde sus inicios, las especificaciones del sistema de coordenadas mundial han venido siendo más y más
sofisticadas: desde muy temprano las imágenes en FITS permitieron un factor escalar simple para
representar el tamaño de los píxeles; pero versiones recientes del estándar permiten múltiples sistemas
de coordenadas no lineales, representando distorsiones arbitrarias de la imagen.
Tablas
FITS también soporta datos tabulados con filas y columnas multidimensionales. Los formatos de tablas
binarios y en ASCII han sido especificados, de tal modo que los datos en cada columna de la tabla
pueden estar en un formato diferente de los demás datos. Junto con la capacidad de múltiples cadenas y
cabeceras o bloques de datos, los archivos FITS pueden representar bases de datos relacionales, así son
capaces de representar desde la información más compleja hasta la más simple.
11
Capítulo 1
Utilizando archivos FITS
FITS está soportado mediante bibliotecas disponibles en los lenguajes más utilizados en el ámbito
científico, incluyendo C, FORTRAN, Perl, PDL, Python, e IDL. La Oficina de Soporte de FITS de la
NASA/GSFC mantiene una lista de bibliotecas y plataformas que actualmente soportan FITS.
El procesado de imágenes con programas como GIMP y photoshop está limitado a la lectura de las
imágenes simples. Es frecuente que no puedan interpretar las tablas y bases de datos más complejas; por
ello, los equipos científicos normalmente escriben sus propios programas para tratar la información que
almacenan en formato FITS.
Muchos entornos científicos hacen uso de un sistema de coodenadas en la cabecera de FITS para
mostrar, comparar, rectificar y realizar otras operaciones que impliquen una manipulación directa de las
imágenes FITS. Un ejemplo es la biblioteca para transformar las coordenadas incluida con PDL, ésta
biblioteca es conocida como PLOT MAP, también está la biblioteca AST escrita en C, perteneciente al
Proyecto Starlink.
1.2 Sistemas de Información Geográficos, propietarios y libres
En el sentido estricto de la palabra un SIG es cualquier sistema de información capaz de integrar,
almacenar, editar, analizar, compartir y mostrar la información geográficamente referenciada. En un
sentido más genérico, los SIG son herramientas que permiten a los usuarios crear consultas interactivas,
analizar la información espacial, editar datos, mapas y presentar los resultados de todas estas
operaciones.Existen en la actualidad dos grupos de SIG en el mundo: los propietarios y los libres
(GUTIERREZ PUEBLA, 1997).
Funcionamiento de un SIG
Un Sistema de Información Geográfica puede mostrar la información en capas temáticas para realizar
análisis multi-criterio complejos (Figura 2). Un SIG se define a menudo como una combinación de un
sistema de gestión de base de datos, un conjunto de operaciones para examinar los datos y un sistema de
visualización gráfica que están vinculados al proceso de análisis espacial.
12
Capítulo 1
Figura 2.Ejemplos de capa temáticas para el análisis multi-criterio de un SIG
Los SIG son herramientas cartográficas que permiten la creación de mapas en tiempo real y el análisis
de los impactos de los cambios en el mapa de forma interactiva (Rhyne, 1997b). Otras definiciones
hacen énfasis en los SIG como disciplina o ciencia aplicada que incluyen en su formulación no solo al
software, sino al hardware, al equipo técnico y la filosofía de trabajo, integrándolo todo de forma global.
Según (Great Britain. Committee of Enquiry into the Handling of Geographic Information, 1987) es un
sistema para capturar, almacenar, comprobar, manipular y visualizar datos que estén espacialmente
referenciados a la tierra. Según (Clarke, 1990) es un sistema automatizado para la captura,
almacenamiento, composición, análisis y visualización de datos espaciales. Otra definición es en la que
se considera como un sistema de hardware, software y procesamiento diseñado para la captura, gestión,
manipulación, análisis, modelado y visualización de datos espacialmente referenciados para resolver
problemas complejos de planeamiento y gestión (Cowen, 1989).
El SIG funciona como una base de datos con información geográfica (datos alfanuméricos) que se
encuentra asociada por un identificador común a los objetos gráficos de un mapa digital. De esta forma,
señalando un objeto se conocen sus atributos e, inversamente, preguntando por un registro de la base de
datos se puede saber su localización en la cartografía.
La razón fundamental para utilizar un SIG es la gestión de información espacial. El sistema permite
separar la información en diferentes capas temáticas y las almacena independientemente, permitiendo
trabajar con ellas de manera rápida y sencilla, facilitando la posibilidad de relacionar la información
existente a través de la topología de los objetos, con el fin de generar otra nueva que no podríamos
obtener de otra forma.
Las principales cuestiones que puede resolver un Sistema de Información Geográfica, ordenadas de
menor a mayor complejidad, son:
13
Capítulo 1
1. Localización: preguntar por las características de un lugar concreto.
2. Condición: el cumplimiento o no de unas condiciones impuestas al sistema.
3. Tendencia: comparación entre situaciones temporales o espaciales distintas de alguna
característica.
4. Rutas: cálculo de rutas óptimas entre dos o más puntos.
5. Pautas: detección de pautas espaciales.
6. Modelos: generación de modelos a partir de fenómenos o actuaciones simuladas.
Por ser tan versátiles, el campo de aplicación de los Sistemas de Información Geográfica es muy amplio,
pudiendo utilizarse en la mayoría de las actividades con un componente espacial. La profunda
revolución que han provocado las nuevas tecnologías ha incidido de manera decisiva en su evolución.
Existen en la actualidad gran diversidad de Sistemas de Información Geográficos, algunos de software
libre y otros de software propietarios. En este subepígrafe analizaremos con profundidad algunos de
ellos.
1.2.1 ARCGIS
ArcGIS es el nombre de un conjunto de productos de software en el campo de los Sistemas de
Información Geográfica o SIG, producido y comercializado por ESRI. Bajo el nombre genérico ArcGIS
se agrupan varias aplicaciones para la captura, edición, análisis, tratamiento, diseño, publicación e
impresión de información geográfica.
ArcGIS Desktop, la familia de aplicaciones SIG de escritorio, es una de las más ampliamente utilizadas,
incluyendo en sus últimas ediciones las herramientas ArcReader, ArcMap, ArcCatalog, ArcToolbox,
ArcScene y ArcGlobe, además de diversas extensiones. ArcGIS Desktop se distribuye comercialmente
bajo tres niveles de licencias que son, en orden creciente de funcionalidades (y coste): ArcView,
ArcEditor y ArcInfo.
ArcView
Es un software GIS para visualizar, crear, manipular y gestionar información geográfica; estos
corresponden a lugares, direcciones, posiciones en terreno, áreas urbanas y rurales; regiones y cualquier
tipo de ubicaciones en terrenos determinados. Esta información es trabajada de manera sistémica, lo que
representa una diferencia sustancial a lo relacionado al trabajo con información planos y mapas,
14
Capítulo 1
permitiéndonos explorar, ver y analizar los datos según parámetros, relaciones y tendencias que presenta
nuestra información, teniendo como resultado nuevas capas de información, mapas y nuevas bases de
datos.
Maniobrabilidad
ArcView GIS es el software desktop más usado de los GIS del mundo, porque entrega de una forma
fácil el trabajo en datos geográficos. Tiene una interfaz gráfica amigable, en la cual se puede desplegar
de manera rápida la información geográfica. El aprendizaje del software es rápido, teniendo algunos
conocimientos de Sistemas de Información Geográfica previos.
Con ArcView GIS se puede construir los mapas dinámicos e inteligentes que permiten a visualizar
patrones, tendencias y singularidades en sus datos. ArcView GIS incluye formas fáciles de levantar
mapas, formatos predefinidos de mapas y una librería de elementos extensa, que permiten elaborar
mapas de calidad rápidos y como el usuario desee. Los mapas terminados se pueden guardar, imprimir,
exportar y ubicar en otros documentos o usos. ArcView GIS también permite visualizar sus datos como
cartas, informes, con volumen, con gráficos e imágenes; teniendo la posibilidad de editarlos
expeditamente (Figura 3).
Figura 3. Visualización de datos con ArcView
Análisis Espacial
15
Capítulo 1
ArcView GIS permite consultar datos, realizar predicciones y examinar relaciones entre estos. ArcView
GIS incluye las herramientas y los procedimientos que permiten analizar datos espaciales y que estos
análisis puedan visualizarse fácilmente. ArcView GIS tiene la gran capacidad de realizar geoprocesos, lo
que permite desarrollar ajustes dinámicos de la información, adaptándola a los requerimientos de
análisis del usuario; con esto se tiene la capacidad de construir procesos analíticos y flujos de trabajo.
Arc-Gis ArcEditor
Para la edición y gestión avanzada de información, ArcEditor es parte de la familia ArcGIS. Con esta
modalidad se puede editar, manipular y gestionar datos de naturaleza geográfica. Tiene toda la
funcionalidad de Arcview GIS, agregando más herramientas que puedan crear, editar y asegurar el
proceso de explotación de datos con una calidad a toda prueba.
ArcEditor está hecho para soportar la edición desde múltiples editores como desde un sólo editor de
datos geográficos. Tiene amplio y variado conjunto de herramientas para trabajar la gráfica y la data
alfanumérica.
Dentro de sus funcionalidades se encuentra:
 Automatizar el control de calidad.
 Diseñar mejor bases de datos geográficas.
 Modelar flujos de trabajo multiusuario.
 Generar y editar entidades gráficas geográficas mediante edición visual.
 Crear y editar elementos de topología.
 Diseñar planes de edición, validación y guardar la información tratada.
 Administrar y explorar redes geométricas.
 Mejorar el rendimiento de la edición.
 Desconectar de la base de datos y realizar edición en trabajos de campo.
ArcEditor se utiliza para trabajar con información compleja. El amplio número de herramientas y los
diferentes procesos de trabajo con que cuenta, permiten generar y mantener la información geográfica de
manera sencilla y eficiente (Figura 4).
16
Capítulo 1
Figura 4.Visualización con Arc-Editor
1.2.2 GvSIG
GvSIG (Generalitat Valenciana SIG) surge como un proyecto amparado por la Generalitat Valenciana
de España que, a finales de 2003, promocionó un concurso para el desarrollo de un SIG con una serie de
características propias como: multiplataforma, de código abierto, modular, sin licencias, interoperable
con formatos de otros programas (Autocad, Microstation, Arcview), y sujeto a estándares de la OGC
(Open Geospatial Consortium) (Anguix and Carrión, 2005). El resultado ha sido una aplicación que ya
tiene disponibles varias versiones al público y gran parte de las funcionalidades propias de los SIG
cubiertas, aunque se desarrolla constantemente. Las funciones básicas que cualquier usuario desearía
como diseño de impresión o soporte de formatos de imagen típicos están incorporadas sin necesidad de
ningún módulo adicional. GvSIG posee una jerarquía de clases bien estructurada para la incorporación
de nuevas funcionalidades. Permite la lectura de varios formatos de datos geográficos y no geográficos
en forma de tablas así como la conexión con varias bases de datos. Este SIG posee las aplicaciones
traducidas a veinte idiomas; toda la documentación está disponible en 5 idiomas, incluyendo español e
inglés, por lo que se ha convertido en un SIG muy popular en el mundo hispano (Anguix, 2009). Se ha
reportado su utilización en varios países europeos como Francia, Italia, Suiza, Austria, Reino Unido y
Alemania, donde se encuentra la mayor comunidad de usuarios de gvSIG no hispanohablantes. Varias
instituciones y universidades prestigiosas han utilizado esta aplicación, tal es el caso de la Agencia
Espacial Europea y Oxford Archaeology. Varios países africanos también han realizado trabajos con
gvSIG, pero su mayor uso se ha reportado en Iberoamérica.
17
Capítulo 1
La simplicidad para la incorporación de nuevas funcionalidades, la disponibilidad de toda su
documentación, el soporte técnico suministrado por la lista de distribución de sus desarrolladores y el
apoyo institucional del proyecto, hace que se considere el SIG más adecuado para la incorporación de un
módulo de visualización científica para el trabajo con formatos de datos científicos.
1.2.3 GRASS
GRASS (de las siglas en inglés Geographic Resources Analysis Support System) fue inicialmente
concebido y desarrollado en 1982 por el laboratorio de investigación del cuerpo de ingenieros del
ejército de los Estados Unidos (USA-CERL) para la gestión del territorio y la gestión medioambiental
(GRASS, 2008). GRASS dispone de un gran número de herramientas y utilidades. Originalmente estuvo
más orientado al aspecto matricial (ráster) de la información, aunque contaba con un potente editor de
topología vectorial. Sin embargo, en las últimas versiones se ha potenciado el aspecto vectorial, y sobre
todo la conexión externa a bases de datos. En cuanto a la interfaz de usuario, también ha experimentado
una gran evolución, teniendo en cuenta que en las primeras versiones todo el control se hacía por medio
de comandos tipo UNIX. Otro gran avance ha sido la herramienta de visualización 3D (NVIZ), que se
destaca por su potencia gráfica y las opciones de generación de salidas gráficas que permite.
1.2.4 El proyecto SEXTANTE
SEXTANTE es un proyecto desarrollado para la Junta de Extremadura por la Universidad de
Extremadura, a través de la Titulación de Ingeniería Técnica Forestal del Centro Universitario de
Plasencia. El objetivo de SEXTANTE es desarrollar un Sistema de Información Geográfica (SIG)
especialmente adaptado para el análisis de datos geográficos, con especial énfasis en las actividades de
gestión del medio y disciplinas afines, este desarrollo se lleva a cabo apoyándose en algún software ya
existente e implementando en el mismo las capacidades requeridas. Originalmente, SEXTANTE tuvo
como base el SIG alemán SAGA, para el cual se desarrollaron un amplio número de extensiones y
modificaciones en su núcleo. Actualmente, gvSIG ha sustituido a SAGA como software base,
principalmente por conformar una estructura de apoyo más sólida y con un mayor potencial de futuro.
Existen cuatro elementos básicos de SEXTANTE, los cuales permiten el acceso a todas las herramientas
de formas diversas, en función de las necesidades de cada usuario y cada proyecto de trabajo (Figura 5):
18
Capítulo 1
Figura 5. Elementos básicos de SEXTANTE
El gestor de extensiones es el elemento principal para el control de las extensiones o módulos. Este
gestor conforma un conjunto de herramientas con todas las extensiones de SEXTANTE que pueden
ejecutarse desde el mismo. A su vez, estas extensiones se agrupan en bloques de acuerdo con el tipo de
análisis que lleven a cabo, para así facilitar su empleo y manejo. (Figura 6).
Figura 6. Gestor de Extensiones
19
Capítulo 1
El modelizador gráfico es una herramienta que permite la creación de modelos complejos mediante una
interfaz sencilla, simplificando procesos que impliquen el uso de varias extensiones de SEXTANTE de
forma encadenada.
Mediante el modelizador puede diseñarse de forma sencilla una nueva extensión que tome datos del
usuario y mediante ellos alimente a una serie de extensiones, de forma que las salidas generadas por
estas puedan ser empleadas como entradas en otras distintas. Procesos que implican varios pasos puede
reducirse así a uno único, definiendo el flujo de datos entre las distintas extensiones involucradas.
El modelizador cuenta con un lienzo de trabajo donde se ve la estructura del modelo planteado, y en la
parte izquierda un conjunto de elementos que se pueden añadir al modelo para ir conformándolo
progresivamente (Figura 7).
Figura 7. El modelizador
La consola de SEXTANTE permite a los usuarios más avanzados hacer un uso más ágil del programa y
automatizar tareas mediante la creación de sencillos scripts (Figura 8).
20
Capítulo 1
Figura 8. Línea de comandos
El historial de procesos registra los distintos procesos que se han llevado a cabo con SEXTANTE, bien
desde el gestor de extensiones o bien desde la línea de comandos. Así, los procesos pueden incluir desde
la ejecución de una extensión de SEXTANTE hasta la creación de una vista o la adición de capas a esta,
entre otras operaciones (Figura 9).
Figura 9. Historial
21
Capítulo 1
1.3 Integración de la Visualización Científica y los Sistemas de Información Geográficos
A finales de los años ochenta y principio de los noventa la VisCi y los SIG se desarrollaron paralela e
independientemente (Rhyne, 1997b). Los esfuerzos para desarrollar estándares de datos espaciales rara
vez consideraron la forma en que estos se visualizaban.
Las bibliotecas gráficas y los estándares evolucionaron independientemente de los modelos de datos.
Como resultado de esto se evidenciaron muchas ineficiencias asociadas con la visualización de datos
geográficos. Entre ellas se incluyen dificultades con el registro de los datos espaciales dentro de
Sistemas de Visualización Científica, engorrosas producciones de secuencias de animaciones en SIG y
quizás la más importante, la falta de conexión entre bases de datos y los ambientes de visualización que
soportaban la visualización de datos espaciales (Hearnshaw and Unwin, 1994). Los desarrolladores de
herramientas SIG y de VisCi hicieron esfuerzos para ampliar e integrar sus sistemas(Rhyne et al., 1994).
Los desarrolladores de SIG estudiaron la forma de incorporar las capacidades de la animación de series
de tiempo en tres dimensiones en su software. Los desarrolladores de herramientas de VisCi
comenzaron la construcción de lectores de datos que soportaban los formatos de datos espaciales como
modelos digitales de elevación, así como formatos de SIG comerciales.
Al examinar estos esfuerzos fueron definidos cuatro niveles de métodos de integración entre SIG y
VisCi: rudimentario, operacional, funcional y mezclado (Rhyne, 1997b).
El enfoque rudimentario utiliza una mínima integración de datos e intercambio entre las dos
tecnologías.
El nivel operacional proporciona coherencia entre los datos mientras se eliminan las redundancias entre
las dos tecnologías (Cook et al., 1997). La forma funcional intenta proporcionar una comunicación
transparente entre los entornos de software correspondientes (Mitas et al., 1997).
El enfoque mezclado se refiere al desarrollo de sistemas donde los conceptos de cartografía, SIG y
VisCi se funden en una única herramienta.
Lograr la integración funcional de SIG y herramientas de VisCi requiere de estándares abiertos de datos
de SIG, enlaces a programas que permitan que las herramientas de VisCi realicen análisis de datos
espaciales y funciones de extracción de información. También es factible el uso de sistemas expertos o
una arquitectura basada en reglas con agentes inteligentes para facilitar la comunicación transparente
entre SIG y herramientas de VisCi(Treinish and Rogowitz, 1993).
Los sistemas que implementan el enfoque mezclado replantean el proceso de desarrollo de herramientas
SIG-VisCi. En este sentido la cartografía está bien posicionada como puente entre ambas tecnologías.
22
Capítulo 1
Algunos de los primeros intentos del enfoque mezclado entre los SIG y la VisCi se han materializado a
través de herramientas como GeoVista Studio y Snap-TogetherVisualization. Ambas herramientas están
basadas en redes de componentes que permiten la construcción de complejos flujos de trabajos que
vinculan componentes para el manejo de formatos de datos geográficos y de diferentes técnicas de
VisCi.
1.3.1 Ejemplos de integración
SnapTogetherVisualization
Snap-Together Visualization es una herramienta Web que permite que los datos de los usuarios sean
mezclados y correlacionados de forma dinámica en visualizaciones coordinadas para la construcción
personalizada de interfaces de exploración sin necesidad de programación. El modelo conceptual de
Snap-Together se basa en un modelo de base de datos relacional. Este modelo permite que las relaciones
sean cargadas durante la visualización y se coordinen basándose en las características que las unen. Los
usuarios pueden crear diferentes tipos de coordinaciones tales como: barridos, vistas de detalles, vistas
globales y desplazamientos sincronizados. Los desarrolladores de visualización pueden integrar al
sistema sus visualizaciones independientes con un API simple. La evaluación de esta herramienta reveló
beneficios en cuanto a aspectos cognitivos y su usabilidad, mejorando el rendimiento de los usuarios
entre un 30 y un 80%, dependiendo de la tarea realizada (North and Shneiderman, 2000).
Algunas de las técnicas de visualización que están incluidas en esa herramienta son los Diagramas de
Dispersión y los TreeMap (North and Shneiderman, 2000).
GeoVista Studio
GeoVista Studio es una herramienta de código abierto que implementa un ambiente de desarrollo basado
en componentes y suministra una interfaz de programación visual como muchos sistemas de VisCi, a
través de la cual los usuarios pueden construir aplicaciones de forma rápida utilizando JavaBeans2. El
ambiente de programación visual permite a los analistas empaquetar funcionalidades dentro de un
programa de trabajo. GeoVista soporta el desarrollo de aplicaciones geográficas y no geográficas.
Para soportar la interoperabilidad de datos OpenGIS, los desarrolladores de GeoVista han comenzado a
adaptar y extender la biblioteca GeoTools en cuanto al acceso a datos y los métodos de visualización.
GeoTools es una biblioteca complementaria de código abierto desarrollada en Java para el desarrollo de
23
Capítulo 1
soluciones OpenGIS que permite el acceso a datos geoespaciales, el análisis y la representación de
tareas.
El principal objetivo de GeoVista Studio es soportar la fusión de diversas capacidades visuales y
analíticas en una herramienta de análisis que posibilite la multiperspectiva. GeoVista incluye además un
conjunto de técnicas de visualización clásicas como Diagramas de Dispersión, Coordenadas Paralelas y
SelfOrganizingMap (SOM (Gahegan et al., 2002, Takatsuka and Gahegan, 2002). La herramienta
ExploratorySpatio-Temporal Analysis Tollkit (ESTAT) fue incluida al GeoVista Studio y constituye una
buena herramienta para analizar datos espaciotemporales asociados a mapas vectoriales de áreas en
formato ESRI shape.
1.3.2 Integración de SIG con formatos de datos científicos, ARCGIS-NetCDF, ARCGIS-HDF
Con el vertiginoso desarrollo de los SIG y las necesidades de la implementación de paquetes dentro de
estos que permitan el trabajo con funcionalidades de datos científicos, ha surgido la necesidad de una
integración de ambas perspectivas con el objetivo de lograr una mejor visión panorámica de la realidad a
visualizar.
En la actualidad el grupo ESRI ha desarrollado una herramienta denominada ArcGis, que incorpora
dentro de sus módulos el trabajo con datos de tipo NetCDF. Todas las versiones siguientes a ArcGis 9.2
poseen esta funcionalidad para el trabajo con formatos de archivo de este tipo (Figura 10).
Figura 10. Trabajo con datos de tipo NetCDF desde ArcGis
Dentro de esta herramienta podemos definir las funcionalidades principales del trabajo con formatos de
tipo NetCDF:
 FeaturetoNetCDF: Convierte una clase punto a un archivo NetCDF (.nc).El nombre del archivo
por defecto es el mismo que el especificado en el nombre de la imagen.
24
Capítulo 1
 MakeNetCDFFeatureLayer: Realiza una capa de imagen a un archivo de tipo NetCDF.
 MakeNetCDFRasterlayer: Realiza una capa Raster a un archivo tipo NetCDF. Para crear una
capa RasterNetCDF el espacio entre las x-coordenadas tiene que ser igual y el espacio entre las
y-coordenadas también. Si no es así, se crea una capa imagen y luego se interpola una capa
Raster.
 Make a NetCDFTable View: Incorpora una vista de tabla al archive creado.
 RastertoNetCDF: Convierte un conjunto de dato ráster a archivo NetCDF.
 SelectbyDimension: Actualiza la visualización de capas o tablas a partir de un parámetro o valor
dado.
 TabletoNetCDF: Convierte una tabla a un archivo tipo NetCDF.
La integración entre los SIG de ESRI y los archivos de datos científicos NetCDF ha permitido que en la
actualidad la utilización de estos productos tenga un amplio espectro a nivel mundial.
Las capacidades de lectura/escritura que brinda NetCDF hacen que este tipo de SIG avance y se coloque
entre los punteros a nivel global, y son utilizadas a menudo dentro de la comunidad atmosférica. La
habilidad de leer conjuntos de datos atmosféricos en su formato natal del NetCDF permite a los usuarios
comunales atmosféricos integrar herramientas y funcionalidad a estas familias de SIG (Settelmaier,
2008)
Anteriomente ArcGIS podía acceder a los archivos HDF con un solo conjunto de datos, pero no podía
acceder a los archivos HDF con varios conjuntos de datos. Se estudió el modelo de datos de GDAL, y se
utilizó la API de GDAL para leer archivos HDF en la memoria, luego, se utilizó la interfaz de
programación de ArcGIS para convertir los datos en memoria para datos ráster a los cuales ArcGIS
puede tener acceso. Con este método, ArcGIS actualmente tiene la capacidad de acceder a los archivos
HDF con múltiples conjuntos de datos (Zhao et al., 2011).
Observaciones
Al usuario que utiliza comúnmente archivos de NetCDF en ArcGIS se le hace en ocasiones un poco
engorroso el trabajo con estos. Existe una herramienta desarrollada por la NASA denominada Panoply,
que le permite un reconocimiento general de este tipo de archivos antes de introducirlos en algún
software de ArcGIS. Esta herramienta le facultará a revisar las variables y las dimensiones de tiempo,
25
Capítulo 1
que le es contenido dentro del archivo del NetCDF, y le da un mejor sentido de lo que el usuario ve
cuando abre el archivo, y trabaja con eso en ArcGIS.
1.4 Conclusiones Parciales
En este capítulo se abordaron cuestiones principales acerca de diferentes formatos de datos científicos,
sus principales características y de cuestiones fundamentales acerca de los SIG, aportando elementos
que reafirman el papel fundamental que juegan en la actualidad en la visualización de datos. Se abordó
también sobre algunos SIG, propietarios y libres, y de la estrecha integración que existe entre la VisCi y
los SIG.
Se concluye que los formatos de datos científicos son una herramienta muy valiosa para el
almacenamiento de un gran volumen de datos en formato digital, que es preciso distribuir y que
depende de la naturaleza de dicha información, además, que su integración con los SIG potencian aún
más su desempeño en la actualidad.
De los formatos de datos científicos mencionados se seleccionó HDF como formato para la
incorporación en un SIG por disponer de una amplia librería implementada en java, además del resto de
las facilidades que posee para el almacenamiento de grandes volúmenes de datos.
De los SIG estudiados la alternativa más viable para la integración de HDF lo constituye el SIG GvSIG
y la biblioteca SEXTANTE, debido a la perfecta integración que existe entre ellos. La ventaja de que
ambos estén implementados en java facilita la integración del formato de datos científico HDF mediante
la biblioteca HDF Java con este SIG.
26
Capítulo 2
Capítulo 2. Módulo de manipulación de archivos HDF en gvSIG
En este capítulo se definen los principales aspectos de la extensión implementada para GVSIG, así como
las funcionalidades del trabajo con datos de formatos HDF que serán implementadas para lograr la
manipulación de este tipo de formatos dentro del SIG seleccionado.
2.1 Diseño de la extensión realizada a gvSIG
El lenguaje UML (Unified Modeling Language) (Rumbaugh and Booch, 2000) fue el utilizado para
realizar el diseño de la herramienta, que tiene como objetivos principales la especificación,
visualización, construcción y documentación de los productos de un sistema de software. Este lenguaje
es usado por el RUP (Rational Unified Process) como lenguaje de modelado para lo cual se basa en
todos sus tipos de diagramas, que constituyen diferentes vistas del modelo del producto.
Los diagramas empleados en el diseño del módulo fueron los siguientes: diagrama de casos de uso y
diagrama de clases.
Diagramas de casos de usos
Los modelos de casos de uso proporcionan un medio sistemático e intuitivo de capturar requisitos
funcionales del sistema basándose en los requerimientos de los usuarios. Este modelo se realiza
identificando cada actor del sistema como los posibles usuarios para los cuales está realizado el mismo.
La extensión implementada está destinada a un solo tipo de actor que es el especialista o investigador de
cualquier rama que desee trabajar con el tipo de datos científicos HDF desde gvSIG y que sean capaces
de interpretar de forma correcta los resultados que brinda la herramienta.
Figura 11. Diagrama de casos de uso
27
Capítulo 2
El caso de uso que se toma en consideración es: trabajo con archivos de datos científicos que es el
objetivo del trabajo, teniendo en cuenta siempre con qué tipo de archivo se está trabajando para poder
hacer un mejor uso de la herramienta. Como instancias de este caso de uso el especialista puede trabajar
con archivos rásters, este trabajo consiste en convertir uno o varios rásters a HDF, también tiene la
opción de hacerlo de manera comprimida en caso de que estos archivos sean demasiados grandes y sea
uno de sus objetivos reducir su tamaño, también puede obtener una serie de estadísticas del mismo. El
caso de uso, trabajo con archivos HDF, se enfoca en convertir de HDF a ráster y HDF a tabla, aquí tiene
la opción de descomprimir el archivo al llevarlos a ráster o a tabla en caso de estarlo. El trabajo con
tablas se dirige a la conversión de tablas a HDF, también lo puede hacer de manera comprimida.
Diagrama de Clases
Un diagrama de clases es un tipo de diagrama estático que describe la estructura de un sistema
mostrando sus clases, atributos y las relaciones entre ellos. Los diagramas de clases son utilizados
durante el proceso de análisis y diseño de los sistemas, donde se crea el diseño conceptual de la
información que se manejará en el sistema, y los componentes que se encargarán del funcionamiento y
la relación entre uno y otro.
Dentro del paquete es.unex.sextante.HDFTools están la mayoría de las clases creadas para el
funcionamiento de la nueva herramienta encargada de la manipulación de archivos HDF. Solo la clase
HDF_Handle no está dentro de ese paquete, se encuentra en el paquete Handles.
28
Capítulo 2
Figura 12. Diagrama de clases dentro de es.unex.sextante.HDFTools
29
Capítulo 2
En la (Figura 12) se muestran los atributos y métodos de las clases que se elaboraron en los paquetes
es.unex.sextante.HDFTools, posteriormente se describirán y se explicarán sus funciones dentro del
proyecto.
Figura 13. Dependencias entre las clases nuevas
En la (Figura 13) se muestran las dependencias entre estas clases revelando a la clase HDF_Handle
como la que controla todo el proceso de ejecución del proyecto.
Figura 14. Asociación entre HDF_Handle y la biblioteca HDF-JAVA
En la (Figura 14) podemos observar las asociaciones de la clase HDF_Handle con H5, H5File,
HDF5Constants y Dataset, que se encuentran en paquetes diferentes y se crean objetos de esas clases.
En estas dependencias se indica si una clase llama, instancia y/o importa a las demás.
30
Capítulo 2
Figura 15. Dependencias de los nuevos algoritmos con GeoAlgorithm
En la (Figura 15) se muestra que los algoritmos implementados derivan de la clase GeoAlgorithm,
posteriormente se explica estas dependencias.
En la (Figura 16) se muestra las dependencias entre los principales paquetes del proyecto, en esta se
puede ver fácilmente la relación entre nuestros paquetes, es.unex.sextante.HDFTools y Handles, con las
demás paquetes de la biblioteca HDF-JAVA.
Figura 16. Dependencias
entre los principales paquetes del proyecto
31
Capítulo 2
2.2 Concepciones importantes en la implementación de la extensión
En este epígrafe se tratan los temas referentes a la implementación de la extensión realizada, teniendo en
cuenta la tecnología utilizada en la confección de la misma, así como algunas consideraciones
importantes a la hora de lograr los objetivos de este trabajo.
Selección de las tecnologías
Durante el desarrollo o extensión de un sistema es importante la elección de la plataforma objetivo y del
lenguaje de desarrollo a utilizar. En cada investigación hay que puntualizar en determinadas áreas
específicas de la aplicación.
Elección del lenguaje de desarrollo
El objetivo de esta investigación es adicionar un módulo que permita el trabajo con el formato de dato
científico HDF mediante Sextante en gvSIG. Tanto este SIG como Sextante están implementados con el
lenguaje Java. El proceso de integración del módulo con el sistema actual inevitablemente tendrá que
interactuar y utilizar los códigos fuentes de gvSIG y Sextante. Esto hace al lenguaje Java la mejor
elección para mantener la mayor compatibilidad posible con el sistema actual.
A las razones descritas anteriormente se puede agregar que este proyecto necesita el trabajo con la
biblioteca HDF-JAVA, una biblioteca desarrollada en java que permite la utilización de múltiples
funciones para manipular archivos HDF. Por otra parte, Sextante se puede integrar con otros SIG,
facilitando una mayor explotación y utilización del módulo propuesto.
Elección del Entorno de Desarrollo Integrado
Existe un conjunto de Entornos de Desarrollo Integrado (IDE, de sus siglas en inglés) que permiten el
desarrollo de proyectos en Java. El IDE Eclipse versión 3.4 fue el seleccionado como ambiente de
programación de esta extensión, debido a que resulta cómodo y fácil de usar para depurar programas.
Posee plugins para el desarrollo de editores visuales que pueden ir desde procesadores de texto hasta
editores de diagramas UML, interfaces gráficas para el usuario (GUI).
Además la estructura de proyectos de gvSIG está diseñada para ser compilado con mayor facilidad
utilizando este IDE.
Elección de la versión de gvSIG a utilizar como sistema base
El progresivo desarrollo de gvSIG por parte de una comunidad de desarrolladores hace posible que con
cierta regularidad se actualice su versión. El modulo para el trabajo con formato HDF se desarrolló en la
versión 1.11.
32
Capítulo 2
2.2.1 Forma general de crear algoritmos en Sextante
Todos los algoritmos que se desarrollen en Sextante deben extender de la clase GeoAlgorithm que
provee la base para todas las operaciones. Al extender de esta clase se implementan dos métodos a
través
de
los
cuales
definen
las
características
del
algoritmo,
defineCharacteristics()
y
processAlgorithm(), además el nombre de la clase debe terminar en Algorithm.
En el método defineCharacteristics() se define la entrada y la salida, se especifica el nombre que va a
tener el algoritmo y el grupo al que va a pertenecer. Los parámetros de entrada se definen teniendo en
cuenta con qué tipo de mapas se piensa trabajar, raster, vectoriales o tablas. Es posible trabajar con listas
de múltiples mapas. Para cada tipo de entrada se debe especificar su parámetro de entrada, nombre por
el que será identificado y en el caso de conjunto de mapas múltiples, un tercero, que indica si se requiere
o no. Hay otras entradas que pueden definirse como valores de selección en el caso de poder trabajar con
varias opciones de cálculo, cadenas de texto, valores booleanos, etc.
En el método processAlgorithm() es donde se debe programar el algoritmo en sí, creando todos los
procesos y cálculos que se deban realizar.
Hay tres tareas fundamentales que deben realizarse para que el algoritmo cumpla su objetivo:

Leer los parámetros de entrada. Los valores deben ser leídos y guardados en variables para hacer
más fácil su uso en el algoritmo.

Trabajar con las variables.

Crear resultados de salida. La salida es lo más importante del algoritmo y deben ser
correctamente definidas para permitir que sea usada por otros algoritmos de Sextante.
2.3 Explicación de las principales funcionalidades del módulo
En este epígrafe se abordarán cuáles son las principales funcionalidades de la extensión. Este proceso
brindará al usuario especializado un conocimiento general acerca de la capacidad y el alcance de la
extensión realizada.
Cuando el usuario se encuentra frente a una herramienta de tal complejidad, se preguntará como puede
convertir un ráster a HDF, múltiples rásters a HDF, una tabla a HDF, un conjunto de datos de un HDF a
ráster, entre otras operaciones dentro de GVSIG. A continuación se brindará información sobre estas
operaciones.
33
Capítulo 2
Raster to HDF
En este algoritmo, primero se implementa el método defineCharacteristics(), en él definimos el nombre
del algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("Raster to HDF");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y de salidas
m_Parameters.addInputRasterLayer("INPUT", "Entrada Raster", true);
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
para este caso el parámetro de entrada será una capa raster que debe estar cargada en una vista del
gvSIG y el parámetro de salida será la dirección donde se desea ubicar el archivo HDF resultante.
Después se implementa el método processAlgorithm(), el cual tiene el mayor peso en el algoritmo. Aquí
se toman las extensiones de la capa ráster, las cuales nos servirán para saber las dimensiones que tendrá
el nuevo conjunto de datos dentro del archivo HDF y se pregunta por el número de bandas de esta, si es
de una sola banda se llena una matriz de 2 dimensiones con los datos del ráster y luego se llama al
método correspondiente de la clase manipuladora para crear el archivo, a continuación se muestra el
código para un ráster de una banda:
float matriz[][] = new float[iNX][iNY];
for (x = 0; x < iNX; x++)
for (y = 0; y < iNY; y++)
matriz[x][y] = layer.getCellValueAsInt(x, y);
HDF_Handle.insertarDataSet(iNX, iNY, matriz, layer.toString(), rl);
Para los ráster de múltiples bandas la diferencia es que la matriz que se crea tiene 3 dimensiones, ya que
la tercera es el número de bandas, el correspondiente código es el siguiente:
int nroB = layer.getBandsCount();
float matriz[][][] = new float[iNX][iNY][nroB];
for (int z = 0; (z < nroB && setProgress(z, nroB)); z++) {
for (y = 0; y < iNY; y++) {
for (x = 0; x < iNX; x++) {
matriz[x][y][z] = layer.getCellValueAsInt(x, y, z);
}
}
}
HDF_Handle.insertarDataSet(iNX, iNY, nroB, matriz, layer.toString(), rl);
34
Capítulo 2
Rasters to HDF
En el algoritmo primero se implementa el método defineCharacteristics(), en el definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("Rasters to HDF");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y de salidas
m_Parameters.addMultipleInput(MULTIPLE, MULTIPLE,
AdditionalInfoMultipleInput.DATA_TYPE_RASTER, true);
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
m_Parameters.requiresMultipleRasterLayers();
para este caso los parámetros de entrada serán rásters que deben estar cargados en una Vista del gvSIG,
el parámetro de salida será la dirección donde se desea ubicar el archivo HDF resultante.
Después se implementa el método processAlgorithm(). Aquí se toman las capas rásters entrantes y se
colocan dentro de un arreglo, para posteriormente recorrerlo.
layerlist = m_Parameters.getParameterValueAsArrayList(MULTIPLE);
final IRasterLayer window[] = new IRasterLayer[layerlist.size()];
for (int i = 0; i < layerlist.size(); i++) {
window[i] = layerlist.get(i);
}
A continuación se procede a recorrer el arreglo de rásters, a cada ráster se les toma las extensiones, las
cuales nos servirán para saber las dimensiones que tendrá el nuevo conjunto de datos dentro del archivo
HDF y se pregunta por el número de bandas de esta, si es de una sola banda se llena una matriz de 2
dimensiones con los datos del ráster y luego se llama al método correspondiente de la clase
manipuladora para crear el archivo. Para los ráster de múltiples bandas la diferencia es que la matriz que
se crea tiene 3 dimensiones, ya que la tercera es el número de bandas, al terminar el análisis de ese
ráster, se continuación el próximo y así sucesivamente hasta que se terminen los rásters. El
correspondiente código es el siguiente:
for (int i = 0; i < window.length; i++) {
GridExtent gridExtent = new GridExtent(window[i]);
window[i].setWindowExtent(gridExtent);
iNX = gridExtent.getNX();
iNY = gridExtent.getNY();
float matriz[][] = new float[iNX][iNY];
35
Capítulo 2
if (window[i].getBandsCount() == 1) {
for (x = 0; x < iNX; x++)
for (y = 0; y < iNY; y++)
matriz[x][y] = window[i].getCellValueAsInt(x, y);
HDF_Handle.insertarDataSet(iNX, iNY, matriz, window[i].toString(), rl);
} else {
int nroB = window[i].getBandsCount();
float matriz1[][][] = new float[iNX][iNY][nroB];
for (int z = 0; (z < nroB && setProgress(z, nroB)); z++) {
for (y = 0; y < iNY; y++) {
for (x = 0; x < iNX; x++) {
matriz1[x][y][z] = window[i].getCellValueAsInt(x,
y, z);
}
}
}
HDF_Handle.insertarDataSet(iNX, iNY, nroB, matriz1,
window[i].toString(), rl);
}
Table to HDF
En el algoritmo primero se implementa el método defineCharacteristics(), en el definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("Table to HDF");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y de salidas
m_Parameters.addInputTable(TABLE, Sextante.getText("Table"), true);
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
para este caso el parámetro de entrada será una tabla que debe estar cargada en una Tabla del gvSIG, el
parámetro de salida será la dirección donde se desea ubicar el archivo HDF resultante.
Después se implementa el método processAlgorithm(). Aquí se toman el número de filas y columnas de
la tabla, las cuales nos servirán para saber las dimensiones que tendrá el nuevo conjunto de datos dentro
del archivo HDF, a continuación se llena una matriz de 2 dimensiones con los datos de la tabla y luego
se llama al método correspondiente de la clase manipuladora para crear el archivo, a continuación se
muestra el código:
36
Capítulo 2
int i;
int iField;
long iCount;
ITable table;
String rl = m_Parameters.getParameter("Path").getParameterValueAsString();
table = m_Parameters.getParameterValueAsTable(TABLE);
i = 0;
iCount = table.getRecordCount();
iField = table.getFieldCount();
float matriz[][] = new float[(int) iCount][iField];
final IRecordsetIterator iter = table.iterator();
while (iter.hasNext() && setProgress(i, (int) iCount)) {
final IRecord record = iter.next();
for (int j = 0; j < iField; j++) {
try {
matriz[i][j] = Float.parseFloat(record.getValue(j)
.toString());
} catch (final NumberFormatException e) { }
i++;
}
iter.close();
HDF_Handle.insertarDataSet((int) iCount, iField, matriz, table.toString(), rl);
Tables to HDF
En el algoritmo primero se implementa el método defineCharacteristics(), en el definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("Tables to HDF");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y de salidas
m_Parameters.addMultipleInput(MULTIPLE, MULTIPLE,
AdditionalInfoMultipleInput.DATA_TYPE_TABLE, true);
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
m_Parameters.requiresMultipleTables();
37
Capítulo 2
para este caso los parámetros de entrada serán tablas que deben estar cargadas en el gvSIG, el parámetro
de salida será la dirección donde se desea ubicar el archivo HDF resultante.
Después se implementa el método processAlgorithm(). Aquí se toman las tablas entrantes y se colocan
dentro de un arreglo, para posteriormente recorrerlo.
layerlist = m_Parameters.getParameterValueAsArrayList(MULTIPLE);
final ITable window[] = new ITable[layerlist.size()];
for (int i = 0; i < layerlist.size(); i++) {
window[i] = layerlist.get(i);
}
A continuación se procede a recorrer el arreglo de tablas, a cada tabla se les toma las dimensiones, las
cuales nos servirán para crear el nuevo conjunto de datos dentro del archivo HDF, luego se llena una
matriz de 2 dimensiones con los datos de la tabla y se llama al método insertarDataSet de la clase
manipuladora para crear el archivo. Al terminar el análisis de esa tabla, se continua con el próximo y así
sucesivamente hasta que se terminen de recorrer el arreglo de tablas. El correspondiente código es el
siguiente:
for (int i = 0; i < window.length; i++) {
k = 0;
iCount = window[i].getRecordCount();
iField = window[i].getFieldCount();
float matriz[][] = new float[(int) iCount][iField];
final IRecordsetIterator iter = window[i].iterator();
while (iter.hasNext() && setProgress(k, (int) iCount)) {
final IRecord record = iter.next();
for (int j = 0; j < iField; j++) {
try {
matriz[k][j] = Float.parseFloat(record.getValue(j)
.toString());
} catch (final NumberFormatException e) {
}
}
k++;
}
iter.close();
HDF_Handle.insertarDataSet((int) iCount, iField, matriz,
window[i].toString(), rl);
38
Capítulo 2
}
Compress Raster to HDF
Este algoritmo es prácticamente igual al Raster to HDF, la diferencia radica en el método a llamar en la
clase controladora, este algoritmo toma un ráster como entrada, pero el archivo HDF que da como
resultado tiene el máximo nivel de compresión que nos da la posibilidad la biblioteca HDF-JAVA. Se
llaman dos métodos dependiendo del número de bandas del archivo.
writeGzip(int DIM_X, int DIM_Y, float[][] arg, String DATASETNAME, String
FILENAME)
writeGzip(int DIM_X, int DIM_Y, int DIM_Z, float[][][] arg, String DATASETNAME,
String
FILENAME)
El primero para el caso en que el raster de entrada sea de una banda y el segundo para el caso que sea de
múltiples bandas.
Compress Table to HDF
Este algoritmo es prácticamente igual al Table to HDF, la diferencia radica en el método a llamar en la
clase controladora, este algoritmo toma una tabla como entrada, pero el archivo HDF que da como
resultado tiene el máximo nivel de compresión que nos da la posibilidad la biblioteca HDF-JAVA. El
método a llamar sería el siguiente:
writeGzip(int DIM_X, int DIM_Y, float[][] arg, String DATASETNAME, String
FILENAME)
Decompress HDF to Raster
Este algoritmo es prácticamente igual al HDF to Raster, la diferencia radica en el método a llamar en la
clase controladora, este algoritmo toma un archivo HDF y un conjunto de datos anteriormente
comprimido como entrada, el resultado será un ráster descomprimido. El método a llamar sería el
siguiente:
readGzip(int DIM_X, int DIM_Y, String DATASETNAME, String FILENAME)
Si es multibanda se llama a
readGzip(int DIM_X, int DIM_Y, int DIM_Z, String DATASETNAME, String FILENAME)
39
Capítulo 2
Decompress HDF to Table
Este algoritmo es prácticamente igual al HDF to Table, la diferencia radica en el método a llamar en la
clase controladora, este algoritmo toma un archivo HDF y un conjunto de datos anteriormente
comprimido como entrada, el resultado será una tabla descomprimida. El método a llamar sería el
siguiente:
readGzip(int DIM_X, int DIM_Y, String DATASETNAME, String FILENAME)
HDF to Raster
En el algoritmo primero se implementa el método defineCharacteristics(), en él definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("HDF to Raster ");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y salidas
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
m_Parameters.addString("DataSet", "DataSetNames");
los parámetros de entradas necesitan que se les especifique el archivo HDF y el nombre del conjunto de
datos y los de salida, la dirección donde se ubicará el archivo ráster, el resultado también se mostrará en
una vista de gvSIG.
Después se implementa el método processAlgorithm(). En él se toman las dimensiones del conjunto de
datos seleccionado, para poder crear el ráster de salida correcto, también se pregunta si el conjunto de
datos es multibanda o no. Si es de una sola banda se llama al método getDataSet de la clase
manipuladora HDF_Handle, este devuelve los datos en una matriz de 2 dimensiones, estos serán
copiados hacia el raster resultante. El código es el siguiente:
result = getNewRasterLayer(this.Resul, "Result",
IRasterLayer.RASTER_DATA_TYPE_INT, gridExtent);
float[][] datasetRes = HDF_Handle.getDataSet(iNX, iNY, dataset, h5file);
for (x = 0; x < iNX; x++)
for (y = 0; y < iNY; y++) {
result.setCellValue(x, y, (int) datasetRes[x][y]);
}
En el caso de que el conjunto de datos sea multibanda, también se llama a un método llamado
getDataSet, de la misma clase manipuladora, pero este devuelve los datos en una matriz de 3
dimensiones, estos son copiados al ráster resultante. El código es el siguiente:
40
Capítulo 2
result = getNewRasterLayer(this.Resul, "Result",
IRasterLayer.RASTER_DATA_TYPE_INT, gridExtent, (int)
dim[2]);
result.setInterpolationMethod(IRasterLayer.INTERPOLATION_NearestNeighbour);
float[][][] datasetRes = HDF_Handle.getDataSet(iNX, iNY, (int) dim[2], dataset,
h5file);
int c = 0;
for (int z = 0; (z < (int) dim[2] && setProgress(z, (int) dim[2])); z++) {
for (y = 0; y < iNY; y++) {
for (x = 0; x < iNX; x++) {
result.setCellValue(x, y, z, (int) datasetRes[x][y][z]);
}
}
}
HDF to Table
En el algoritmo primero se implementa el método defineCharacteristics(), en él definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
this.setName("HDF to Table ");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y salidas
m_Parameters.addFilepath("Path", "URL", true, true, "HDF");
m_Parameters.addString("DataSet", "DataSetNames");
los parámetros de entradas necesitan que se les especifique el archivo HDF y el nombre del conjunto de
datos. Los de salida, la dirección donde se ubicará la tabla, el resultado también se mostrará en una tabla
de gvSIG.
Después se implementa el método processAlgorithm(). En él se toman las dimensiones del conjunto de
datos seleccionado, para poder crear la tabla de salida correcta. Luego se inicializan las variables
auxiliares, estas son importantes ya serán las que nos permitirán dar los nombres a los campos de la
tabla y también el tipo de los datos que se almacenarán, entre otras funciones. A continuación se llama al
método getDataSet de la clase manipuladora HDF_Handle, este devuelve los datos en una matriz de 2
41
Capítulo 2
dimensiones, estos serán copiados hacia la tabla resultante. Los datos se copian de fila en fila, ya que los
datos se le pasan a la tabla de esta manera, una vez copiados los datos de una fila, estos se copian a la
tabla. El código es el siguiente:
dim = HDF_Handle.getDims(h5file, dataset);
iNX = (int) dim[0];
iNY = (int) dim[1];
sFields = new String[iNY];
types = new Class[iNY];
values = new Object[iNY];
for (int i = 0; (i < iNY && setProgress(i, iNY)); i++) {
sFields[i] = Float.toString(i);
types[i] = Float.class;
}
result = getNewTable(this.Resul, "Result", types, sFields);
float[][] datasetRes = HDF_Handle.getDataSet(iNX, iNY, dataset, h5file);
for (int j = 0; (j < iNX) && setProgress(j, iNX); j++) {
for (int k = 0; (k < iNY ); k++) {
values[k] = new Float(datasetRes[j][k]);
}
result.addRecord(values);
}
Basic Statistics Raster
En el algoritmo, al igual que en los anteriores, primero se implementa el método defineCharacteristics(),
en él definimos el nombre del algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente
código:
this.setName("Basic Statistics Raster ");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y salidas
m_Parameters.addInputRasterLayer("INPUT", "Entrada Raster", true);
addOutputTable(Resul, "Table");
el parámetro de entrada necesita que se le especifique el archivo ráster, que debe estar cargado
anteriormente en una vista de gvSIG. El de salida, la dirección donde se ubicará la tabla, el resultado
también se mostrará en una tabla de gvSIG.
42
Capítulo 2
Después se implementa el método processAlgorithm(). En él se toman las dimensiones del ráster
seleccionado, para poder crear la tabla de salida correcta y se pregunta por el número de bandas de esta,
si es de una sola banda se toman los datos de uno en uno y se le pasan como parámetros a una instancia
de la clase SimpleStats, que es la encargada de buscar las estadísticas básicas de un conjunto de datos.
Luego se llena el arreglo con las estadísticas que se quieran almacenar en la tabla resultante, por último
se le pasa este arreglo a la tabla, el siguiente código muestra lo antes descrito:
IRasterLayer layer = m_Parameters.getParameterValueAsRasterLayer("INPUT");
GridExtent gridExtent = new GridExtent(layer);
layer.setWindowExtent(gridExtent);
layer.setInterpolationMethod(IRasterLayer.INTERPOLATION_NearestNeighbour);
iNX = gridExtent.getNX();
iNY = gridExtent.getNY();
types = new Class[7];
values = new Object[7];
for (i = 0; i < sFields.length; i++) {
types[i] = Float.class;
}
result = getNewTable(this.Resul, "Basic-Statistics-" + layer.toString(), types,
sFields);
if (layer.getBandsCount() == 1) {
SimpleStats stats = new SimpleStats();
for (x = 0; x < iNX; x++)
for (y = 0; y < iNY; y++) {
dValue = layer.getCellValueAsInt(x, y);
stats.addValue(dValue);
}
values[0] = new Float(stats.getMean());
values[1] = new Float(stats.getRMS());
values[2] = new Float(stats.getMin());
values[3] = new Float(stats.getMax());
values[4] = new Float(stats.getVariance());
values[5] = new Float(stats.getSum());
values[6] = new Float(stats.getCoeffOfVar());
43
Capítulo 2
if (m_Task.isCanceled()) {
return false;
}
result.addRecord(values);
}
Para el caso que el ráster es multibanda también se van tomando los datos de uno en uno, pero se
almacenar en la tabla, en cada fila, las estadísticas de las bandas, es decir, cada fila de la tabla va a
corresponder con las estadísticas de una banda, el código es el siguiente:
int nroB = layer.getBandsCount();
for (int z = 0; (z < nroB && setProgress(z, nroB)); z++) {
SimpleStats stats = new SimpleStats();
for (y = 0; y < iNY; y++) {
for (x = 0; x < iNX; x++) {
dValue = layer.getCellValueAsInt(x, y, z);
stats.addValue(dValue);
}
}
values[0] = new Float(stats.getMean());
values[1] = new Float(stats.getRMS());
values[2] = new Float(stats.getMin());
values[3] = new Float(stats.getMax());
values[4] = new Float(stats.getVariance());
values[5] = new Float(stats.getSum());
values[6] = new Float(stats.getCoeffOfVar());
if (m_Task.isCanceled()) {
return false;
}
result.addRecord(values);
}
Basic Statistics Table
En el algoritmo primero se implementa el método defineCharacteristics(), en él definimos el nombre del
algoritmo y el grupo al que pertenecerá, esto se hace mediante el siguiente código:
44
Capítulo 2
this.setName("Basic Statistics Table ");
this.setGroup("Tools HDF");
Luego se definen los parámetros de entradas y salidas
m_Parameters.addInputTable(TABLE, Sextante.getText("Table"),true);
addOutputTable(Resul, "Table");
el parámetro de entrada necesita que se le especifique la tabla a la que se le quiere aplicar el algoritmo,
que debe estar cargada anteriormente en gvSIG. El de salida, la dirección donde se ubicará la tabla, el
resultado también se mostrará en una tabla de gvSIG.
Después se implementa el método processAlgorithm(). Aquí se toman el número de filas y columnas de
la tabla, las cuales nos servirán poder crear la tabla de salida correcta, luego se toman los datos de uno
en uno y se le pasan como parámetros a una instancia de la clase SimpleStats, que es la encargada de
buscar las estadísticas básicas de un conjunto de datos. Luego se llena el arreglo con las estadísticas que
se quieran almacenar en la tabla resultante, por último se le pasa este arreglo a la tabla, el siguiente
código muestra lo antes descrito:
table = m_Parameters.getParameterValueAsTable(TABLE);
iCount = table.getRecordCount();
iField = table.getFieldCount();
types = new Class[7];
values = new Object[7];
for ( i = 0; i < sFields.length; i++) {
types[i] = Float.class;
}
result = getNewTable(this.Resul, "Basic-Statistics-"+table.toString(), types,
sFields);
final IRecordsetIterator iter = table.iterator();
i = 0;
while (iter.hasNext() && setProgress(i, (int) iCount)) {
final IRecord record = iter.next();
for (int j = 0; j < iField; j++) {
try {
dValue = Float.parseFloat(record.getValue(j)
.toString());
45
Capítulo 2
stats.addValue(dValue);
} catch (final NumberFormatException e) {
}
}
i++;
}
iter.close();
values[0] = new Float(stats.getMean());
values[1] = new Float(stats.getRMS());
values[2] = new Float(stats.getMin());
values[3] = new Float(stats.getMax());
values[4] = new Float(stats.getVariance());
values[5] = new Float(stats.getSum());
values[6] = new Float(stats.getCoeffOfVar());
if (m_Task.isCanceled()) {
return false;
}
result.addRecord(values);
return true;
}
2.4 Principales métodos de la clase manipuladora
También es importante mencionar y explicar los principales métodos de la clase manipuladora
HDF_Handle. Esta clase tiene implementada dos métodos con el mismo nombre, llamados
insertarDataSet, ellos se utilizan con el mismo fin, que es crear un conjunto de datos dentro de un HDF,
lo mismo sea en uno nuevo o en uno creado. La diferencia radica en el número de parámetros que tienen
ambos, ya que uno es para crear un conjunto de datos de una banda y el otro para multibanda. El primero
tiene 5 parámetros, el número de elementos por columnas, el número de elementos por fila, una matriz
de 2 dimensiones con los datos, el nombre del conjunto de datos y el nombre del archivo HDF. El
46
Capítulo 2
segundo tiene un parámetro más que es el número de bandas y la matriz de los datos entrante es de 3
dimensiones, los demás parámetros son iguales.
A continuación se describirá el método de 5 parámetros solamente por su similitud con el otro de igual
nombre. Primeramente en el método se pregunta si el archivo HDF existe o si hay que crearlo, si existe
hay que abrirlo, para ello se llama al método H5Fopen de la clase H5 y si hay que crearlo se llama a
H5Fcreate de la misma clase, el código se muestra a continuación:
File f = new File(FILENAME);
if (f.exists()) {
try {
file_id = H5.H5Fopen(FILENAME, HDF5Constants.H5F_ACC_RDWR,
HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
} else {
// Create a new file using default properties.
try {
file_id = H5.H5Fcreate(FILENAME, HDF5Constants.H5F_ACC_TRUNC,
HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
}
Luego, se procede a crear el espacio de datos y el conjunto de datos, el espacio de datos se crea con el
método H5Screate_simple y el conjunto de datos se crea con H5Dcreate, ambos métodos de la clase H5.
try {
filespace_id = H5.H5Screate_simple(2, dims, null);
} catch (Exception e) {
e.printStackTrace();
}
// Create the dataset. We will use all default properties for this
// example.
try {
if ((file_id >= 0) && (filespace_id >= 0))
dataset_id = H5.H5Dcreate(file_id, DATASETNAME,
47
Capítulo 2
HDF5Constants.H5T_STD_I32LE, filespace_id,
HDF5Constants.H5P_DEFAULT,
HDF5Constants.H5P_DEFAULT,
HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
Después se copian los datos que se entran por parámetro en la matriz arg para el conjunto de datos. El
método utilizado es H5Dwrite, últimamente se cierra el conjunto de datos mediante el método
H5Dclose, se cierra el espacio de datos y el archivo, mediante los métodos H5Sclose y H5Fclose,
respectivamente. Este método no devuelve nada. Lo antes descrito se ve a continuación el código.
// Write the data to the dataset.
try {
if (dataset_id >= 0)
H5.H5Dwrite(dataset_id, HDF5Constants.H5T_NATIVE_FLOAT,
HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL,
HDF5Constants.H5P_DEFAULT, arg);
} catch (Exception e) {
e.printStackTrace();
}
// End access to the dataset and release resources used by it.
try {
if (dataset_id >= 0)
H5.H5Dclose(dataset_id);
} catch (Exception e) {
e.printStackTrace();
}
try {
if (filespace_id >= 0)
H5.H5Sclose(filespace_id);
} catch (Exception e) {
e.printStackTrace();
}
// Close the file.
48
Capítulo 2
try {
if (file_id >= 0)
H5.H5Fclose(file_id);
} catch (Exception e) {
e.printStackTrace();
}
En la clase HDF_Handle también existen 2 métodos con el nombre writeGzip, pasa exactamente lo
mismo que con los métodos anteriores, uno para crear conjunto de datos de una banda y otro para
multibanda, los parámetros son los mismos de los métodos insertarDataSet, la diferencia de estos dos
métodos con los anteriores es que crean conjuntos de datos comprimidos, para ello crean una lista de
propiedades en cual le da el nivel de compresión y se le define el tamaño del chunk, esto se hace
mediante los métodos H5Pset_deflate y H5Pset_chunk, luego, se le pasa esta lista de propiedades al
método que creará el conjunto de datos, en este caso H5Dcreate, todos de la clase H5, el código que se
muestra a continuación aclara lo antes descrito:
// Create the dataset creation property list, add the gzip compression
// filter.
try {
dcpl_id = H5.H5Pcreate(HDF5Constants.H5P_DATASET_CREATE);
if (dcpl_id >= 0) {
H5.H5Pset_deflate(dcpl_id, 9);
// Set the chunk size.
H5.H5Pset_chunk(dcpl_id, 2, chunk_dims);
}
} catch (Exception e) {
e.printStackTrace();
}
// Create the dataset.
try {
if ((file_id >= 0) && (filespace_id >= 0) && (dcpl_id >= 0))
dataset_id = H5.H5Dcreate(file_id, DATASETNAME,
HDF5Constants.H5T_STD_I32LE, filespace_id,
HDF5Constants.H5P_DEFAULT, dcpl_id,
HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
49
Capítulo 2
}
Otros de los métodos implementados son los getDataSet, estos dos métodos son bastante parecidos, uno
es para leer los datos de un conjunto de datos de una banda y el otro para leer los datos de un conjunto
de datos multibanda, a los dos se le pasan por parámetros las dimensiones de las columnas y las filas, el
nombre del conjunto de datos y del fichero HDF, en el caso del último, también se le pasa el número de
bandas. Ambos métodos primero confirman que el archivo pasado por parámetro exista, si existe, lo abre
mediante el método H5FOpen y también abre el conjunto de datos requerido mediante el método
H5Dopen, el código se muestra a continuación:
// Open file using the default properties.
File f = new File(FILENAME);
if (f.exists()) {
try {
file_id = H5.H5Fopen(FILENAME, HDF5Constants.H5F_ACC_RDONLY,
HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
} else
System.out.println("El archivo especificado no existe");
// Open dataset using the default properties.
try {
if (file_id >= 0)
dataset_id = H5.H5Dopen(file_id, DATASETNAME,
HDF5Constants.H5P_DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
Luego, se procede a leer y copiar los datos del conjunto de datos hacia un arreglo de 2 o 3 dimensiones,
en dependencia de este, esto se hace a través del método H5DRead, una vez terminado la lectura, se
cierra el conjunto de datos y luego el archivo, por último se devuelven los datos almacenados en el
arreglo.
// Read the data using the default properties.
try {
if (dataset_id >= 0)
50
Capítulo 2
H5.H5Dread(dataset_id, HDF5Constants.H5T_NATIVE_FLOAT,
HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL,
HDF5Constants.H5P_DEFAULT, dset_data);
int c = 0;
for (int x = 0; x < DIM_X; x++) {
for (int y = 0; y < DIM_Y; y++) {
setdat[x][y] = dset_data[c];
c++;
}
}
} catch (Exception e) {
e.printStackTrace();
}
// Close the dataset.
try {
if (dataset_id >= 0)
H5.H5Dclose(dataset_id);
} catch (Exception e) {
e.printStackTrace();
}
// Close the file.
try {
if (file_id >= 0)
H5.H5Fclose(file_id);
} catch (Exception e) {
e.printStackTrace();
}
return dsetdat;
Por último, describiremos los dos métodos readGZip, con ellos pasa exactamente lo mismo que con los
dos métodos anteriores, uno para leer conjuntos de datos de una banda y otro para multibanda, los
parámetros son los mismos de los métodos getDataSet, la diferencia de estos dos métodos con los
anteriores es que ellos leen los conjuntos de datos comprimidos anteriormente, para ellos recuperan la
lista de propiedades del conjunto de datos, en la cual está el nivel de compresión y el tamaño del chunk,
esto lo hacemos mediante el métodos H5Dget_create_plist, luego se le pasa al método que leerá y
51
Capítulo 2
copiará el conjunto de datos, en este caso H5Dread, todos de la clase H5, después se cierra el conjunto
de datos y el archivo y se retorna el arreglo con la información descomprimida, el código a continuación
muestra la recuperación de la lista de propiedades y la lectura del conjunto de datos:
// Retrieve the dataset creation property list.
try {
if (dataset_id >= 0)
dcpl_id = H5.H5Dget_create_plist(dataset_id);
} catch (Exception e) {
e.printStackTrace();
}
// Read the data using the default properties.
try {
if (dataset_id >= 0) {
H5.H5Dread(dataset_id, HDF5Constants.H5T_NATIVE_FLOAT,
HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL,
HDF5Constants.H5P_DEFAULT, dset_data);
int c = 0;
for (int x = 0; x < DIM_X; x++) {
for (int y = 0; y < DIM_Y; y++) {
dsetdat[x][y] = dset_data[c];
c++;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
2.5 Conclusiones parciales
La integración de técnicas de VisCi para el trabajo con archivos de datos científicos en el SIG gvSIG,
siguiendo un enfoque mezclado entre estas dos disciplinas, le permite al usuario trabajar con conjuntos
de datos, que no podían ser procesados dentro de sus funcionalidades, obteniendo una visión más
general, y agregando nuevas facilidades para el procesamiento de grandes cantidades de información.
Se incorporaron nuevas funcionalidades a gvSIG, que permiten el trabajo con grandes conjuntos de
información a partir de trabajo con archivos HDF. La implementación de un módulo de este tipo ofrece
52
Capítulo 2
una gran cantidad de beneficios, los cuales hacen que este SIG sea una herramienta más completa y
abarcadora, ofreciéndole al usuario especializado una manera más eficaz y dinámica para el trabajo con
grandes volúmenes de datos.
53
Capítulo 3
Capítulo 3. Presentación de los resultados
En este capítulo se expone lo referente al uso de la extensión, teniendo en cuenta las
funcionalidades del trabajo con archivos de tipos de datos científicos y el procedimiento para crear
un HDF con una estructura especializada.
3.1
Manual de usuario
Para la correcta utilización de la herramienta integrada a gvSIG se requiere el desarrollo de un
manual de usuario. Este epígrafe muestra el uso de cada una de las funcionalidades principales de la
extensión. Se irá desglosando por partes para un mejor entendimiento. En nuestra herramienta el
primer paso es solo para una parte de nuestras funcionalidades, como son las de llevar los datos
desde un ráster a un HDF, de varios rásters a HDF y de almacenar los datos de un ráster en forma
comprimida dentro de un HDF. Para poder hacer uso de estas funcionalidades es necesario tener
preparados los ráster con anterioridad.
Figura 17. Creación de una nueva vista
54
Capítulo 3
En la (Figura 17) se muestran los pasos para establecer una nueva vista, los cuales son: elegir el tipo de
documento que se va a visualizar, identificado con el número uno; crear un documento nuevo,
oprimiendo el botón Nuevo (número dos); seleccionar el documento nuevo (número tres) y oprimir el
botón Abrir para abrirlo (número cuatro). Si se desea se puede cambiar el nombre del documento
oprimiendo en Renombrar. Después de seguir estos pasos se mostrará una vista como la que se resalta
con el número cinco.
Luego de abrir el documento se procede a añadir las capas necesarias para ejecutar la operación, para lo
cual se debe oprimir el botón señalado con el uno en la (Figura 18). En ese entonces se muestra un
diálogo para seleccionar la ubicación de los archivos rásters y se cargarán como capas en el documento,
para este caso cargaremos dos rásters, ya que haremos uso de la funcionalidad de convertir varios rásters
a HDF.
Figura 18. Adición de capas
Una vez cargadas las capas se procede a ejecutar el algoritmo. Primero hay que oprimir el botón del
Gestor de Extensiones de Sextante, señalado con el uno en la (Figura 19). Luego se selecciona el grupo
de algoritmos nuevo, llamado Tools HDF, se muestra con el número 2 en la (Figura 19), se da clic
sobre él y se muestran los algoritmos disponibles a utilizar. Dentro de ellos, Raster to HDF, Rasters to
HDF, Basic Statistics Raster y Compress Raster to HDF, están disponibles ya que los datos necesarios
para ellos están cargados en la vista. En el caso de HDF to Raster, Decompress HDF to Raster y
Decompress HDF to Table, siempre están habilitados ya que los datos que necesitan como entrada se
toman al ejecutarse, es decir, ellos no necesitan tener cargado ningún dato en el gvSIG anteriormente.
Table to HDF, Tables to HDF, Compress Table to HDF y Basic Statistics Table, están deshabilitados
porque ellos sí necesitan tener cargado al menos una tabla anteriormente, pero el proceso es similar al de
cargar un ráster, solo que en lugar de crear una nueva vista, se crea una Tabla y posteriormente se carga.
En este caso se escogió Rasters to HDF, como se muestra señalado con tres en la (Figura 19).
55
Capítulo 3
Figura 19. Selección del algoritmo
Una vez escogido el algoritmo se muestra una nueva ventana, en la cual se definen los parámetros
necesarios para este, como se muestra en la (Figura 20).
Figura 20. Entrada de los parámetros del algoritmo
56
Capítulo 3
En la (Figura 20) se muestran la ventana donde se entran los parámetros necesarios. Oprimiendo el
botón señalado con uno se muestra una ventana donde se pueden escoger dentro de los rásters cargados
con anterioridad en la vista, los deseados para convertir a HDF, se seleccionan los archivos y se presiona
el botón Aceptar, señalado con uno en la (Figura 21).
Figura 21. Selección de las capas
Una vez cargados los archivos se presiona el botón señalado con 2 en la (Figura 20), para introducir la
dirección donde se guardará el fichero HDF, también es necesario escribir como se llamará este .h5.
Luego se presiona el botón Aceptar señalado con 3 en la (Figura 20) y se ejecuta el algoritmo, el
resultado de este se puede ver abriendo el fichero con el HDFView como se muestra en la (Figura 22).
57
Capítulo 3
Figura 22. Archivo HDF resultante
3.2
Caso de Estudio
En el siguiente epígrafe se hará uso de las herramientas creadas para elaborar un archivo HDF con una
estructura específica que permitirá que sus datos sean analizados por el módulo de Visualización
Científica de gvSIG.
Los datos se presentan en una rejilla de alta resolución con 203 puntos espaciados meridiana y
zonalmente unos 50 y 60 Km respectivamente y distribuidos por el territorio de la España peninsular y
Baleares (Figura 23). Esta rejilla fue obtenida por (Borén et al., 1997) a partir del banco de datos de la
Agencia Estatal de Meteorología del Gobierno de España (AEMET) interpolando los datos diarios de los
observatorios disponibles próximos a los puntos. Para el cálculo de las variables (precipitación,
temperaturas máxima y mínima) en el punto se determinó la media ponderada de dichos datos de
observatorios siendo las ponderaciones las inversas de las distancias observatorio-punto y tomando las
distancias inferiores o iguales a 10 km en cualquier caso; de esta manera el dato de cada punto de la
rejilla viene a ser una representación promedio de su área de influencia. Las series así obtenidas y
homogeneizadas para cada punto constituyen una base de datos sin ninguna laguna.
58
Capítulo 3
Figura 23. Mapa con la numeración de cada punto de la rejilla de interpolación.
Cada fichero de cada variable contiene un registro por cada día de cada mes y de cada año ordenados
ascendentemente: el primer registro corresponde al 1-1-1961 y el último al 31-12-1990. En cada registro
aparecen todos los datos de la variable de que se trate en los 203 puntos de rejilla para ese día.
Para crear el archivo HDF primeramente se creó un archivo ráster correspondiente a la rejilla de que se
muestra en la (Figura 23), este quedó como se observa en la (Figura 24).
Figura 24. Raster creado como índice
59
Capítulo 3
A continuación se cargan los tres archivos en forma de tabla en el gvSIG, cada archivo corresponde con
las variables del problema, además se carga el ráster mostrado anteriormente, ya que este formará parte
del archivo HDF. Una vez cargado los todos los datos se procede a hacer uso de las herramientas. Este
proceso de creación del HDF se puedo hacer totalmente automático utilizando el Modeler de Sextante,
en el mismo se hizo un flujo de trabajo como se muestra en la (Figura 25), siempre utilizando las
herramientas creadas.
Figura 25. Modelo para crear el archivo ESPANA.h5 de manera automática dentro del Modeler de
Sextante.
En los componentes de Tablas, se le asigna a cada uno, una tabla como entrada que serán las tres
variables del problema, la capa ráster tomará como entrada el archivo ráster que nos servirá de índice en
el HDF. A cada tabla se le aplica el algoritmo Basic Statistics Table, que este devuelve una tabla con las
estadísticas básicas, esto se hace ya que es necesario para el futuro análisis que se podrán hacer con el
módulo de Visualización Científica del gvSIG de estos datos. Tanto a las tablas que contienen los datos
de las variables, como a las de las estadísticas, se les aplica el algoritmo Tables to HDF, dándole como
salida a este algoritmo en ambos casos al aplicarse, el mismo nombre de salida, para este caso
ESPANA.h5. Por último se aplica al ráster el algoritmo Raster to HDF, también dándole como salida el
60
Capítulo 3
mismo nombre, ya que se quiere que todos estos datos estén dentro del mismo archivo HDF. Como
resultado se muestra este archivo en la (Figura 26).
Figura 26. Archivo ESPANA.h5
3.3
Conclusiones parciales
En el presente capítulo se expusieron los aspectos fundamentales para el uso de las herramientas de
trabajo con datos científicos dentro de gvSIG. Esto constituye una importante guía para el uso eficiente
de las herramientas por parte de los usuarios.
Se presentó un ejemplo para ilustrar a los potenciales usuarios en el uso de la extensión, se analizó el
mismo y se constataron las ventajas que ofrece la implementación de un módulo para este tipo de trabajo
dentro de un SIG.
61
Conclusiones
Conclusiones
Como resultado de esta investigación, se desarrolló un grupo de herramientas para el trabajo con
archivos de formatos de datos científicos, específicamente HDF, que, mediante la integración entre la
Visualización Científica y los SIG, permite las operaciones sobre datos de formato HDF desde gvSIG,
cumpliéndose el objetivo general planteado. Además, se presentaron los siguientes aspectos:
 Se analizaron las principales herramientas para la manipulación de formatos de datos científicos
HDF, NetCDF, etc., con el objetivo de valorar las ventajas de la integración de estas
herramientas a los SIG.
 Se seleccionó el SIG gvSIG para la incorporación de estas herramientas de trabajo con archivos
HDF implementado mediante el enfoque mezclado de las VisCi y los SIG.
 Se desarrolló un diseño detallado de las principales clases que componen la extensión con el
objetivo de agregarle otras funcionalidades en caso de necesitarse en un futuro cercano.
 Se desarrolló un manual de usuario donde se exponen las principales funciones implementadas,
brindando una forma eficaz para el trabajo especializado con la herramienta creada.
La herramienta implementada es de propósito general, permitiendo su utilización en diferentes esferas
de la vida cotidiana, donde se necesite manipular grandes volúmenes de información, para poder
analizar y dar un buen uso a esta.
62
Recomendaciones
Recomendaciones
Al concluir la presente investigación, solo resta hacer algunas recomendaciones, tales como:
 Implementar otras funcionalidades que amplíen el uso de esta herramienta por usuarios
especializados.
 Probar la efectividad del módulo implementado en otro dominio de aplicación.
63
Bibliografía
Bibliografía
ANGUIX, A. 2009. gvSIG: un proyecto global Casos de éxito. Primera jornada de
Latinoamérica y el caribe de usuarios de gvSIG [Online].
ANGUIX, A. & CARRIÓN, G. gvSIG: Soluciones Open Source en las tecnologías espaciales.
GISPLANET 2005, 2005.
BOLSTAD, P. 2005. GIS Fundamentals: A first text on Geographic Information Systems, White
Bear Lake, Minnesota, Eider Press.
BORÉN, R., RIBALAYGUA, J. & BALAIRÓN, L. 1997. Método analógico de simulación de
escenarios climáticos a escala comarcal. Informe Técnico.
CLARKE, K. 1990. Analytical and Computer Cartography, Prentice Hall Professional Technical
Reference.
COOK, D., SYMANZIK, J., MAJUREA, J. J. & CRESSIEB, N. 1997. Dynamic graphics in a
GIS: more examples using linked software. Computers & Geosciences, 23, 371-385.
COWEN, D. 1989. NCGIA lecture.
GAHEGAN, M., TAKATSUKA, M., WHEELER, M. & HARDISTY, F. 2002. Introducing
GeoVISTA Studio: an integrated suite of visualization and computational methods for
exploration and knowledge construction in geography. , Oxford, ROYAUME-UNI,
Elsevier.
GRASS. 2008. Geographic Resources Analysis Support System [Online]. Available:
http://grass.itc.it [Accessed 15 de Febrero de 2010.
GREAT BRITAIN. COMMITTEE OF ENQUIRY INTO THE HANDLING OF GEOGRAPHIC
INFORMATION 1987. Handling geographic information: report to the Secretary of State
for the Environment of the Committee of Enquiry into the Handling of Geographic
Information / Chairman, Lord Chorley, London, H.M.S.O.
GUTIERREZ PUEBLA, J. G., M. 1997. "SIG: Sistemas de Información Geográfica". Madrid.
HEARNSHAW, H. M. & UNWIN, D. J. 1994. Visualization in geographical information systems,
Chichester.
LONG, Q., ZHANG, Q., VILHJALMSSON, B. J., FORAI, P., SEREN, Ü. & NORDBORG, M.
2013. JAWAMix5: an out-of-core HDF5-based java implementation of whole-genome
association studies using mixed models. Bioinformatics.
MITAS, L., BROWN, W. M. & MITASOVA, H. 1997. Role of dynamic cartography in
simulations of landscape processes based on multi-variate fields. Computers &
Geosciences, 23, 437- 446
MORELL, A. & PÉREZ, C. 2006. Biblioteca de módulos de visualización de fluidos para
OpenDX.
NORTH, C. & SHNEIDERMAN, B. 2000. Snap-Together visualization: Can users construct
and operate coordinated visualizations? Int. J. Hum.-Comput. Stud., 53, 715-739.
POINOT, M. 2010. Five good reasons to use the hierarchical data format. Computing in
Science & Engineering, 12, 84-90.
RHYNE, T. M. 1997a. Going virtual with geographic information and scientific visualization.
Computers & Geosciences, 23, 489-491.
RHYNE, T. M. 1997b. Going virtual with Geographic Information and Scientific Visualization
Computers & Geosciences, 23, 489 - 491.
Bibliografía
RHYNE, T. M., IVEY, W., KNAPP, L., KOCHEVAR, P. & MACE, T. 1994. Visualization and
Geographic Information System integration: What are the needs and requirements, if
any ? (Panel). IEEE Computer Society.
RUMBAUGH, J. & BOOCH, G. 2000. El Lenguaje Unificado de Modelado. Manual de
Referencia, Madrid, Addison Wesley.
SETTELMAIER, J. B. 2008. 4B. 2 USE OF A GEOGRAPHIC INFORMATION SYSTEMS (GIS)
TO ASSESS GRIDDED WEATHER FORECASTS. ams.confex.com [Online].
TAKATSUKA, M. & GAHEGAN, M. 2002. GeoVISTA Studio: a codeless visual programming
environment for geoscientific data analysis and visualization. Computers &
Geosciences, 28(10), 1131-1144.
TREINISH, L. A. & ROGOWITZ, B. E. 1993. An Architecture for Perceptual Rule-Based
Visualization.
ULLMAN, R. & DENNING, M. HDF5 for NPP sensor and environmental data records.
Geoscience and Remote Sensing Symposium (IGARSS), 2012 IEEE International,
2012. IEEE, 1100-1103.
YEH, P.-S., XIA-SERAFINO, W., MILES, L., KOBLER, B. & MENASCE, D. Implementation of
CCSDS lossless data compression in HDF. Earth Science Technology Conference,
2002.
ZHAO, J., WANG, Y. & ZHANG, H. Automated batch processing of mass remote sensing and
geospatial data to meet the needs of end users. Geoscience and Remote Sensing
Symposium (IGARSS), 2011 IEEE International, 2011. IEEE, 3464-3467.