Bienvenidos al Blog de la Comunidad Argentina de GvSIG

La idea de esta Blog es reunir a los usuarios, desarrolladores, interesados y recursos en Argentina del Proyecto GvSIG

miércoles, 19 de octubre de 2016

Retransmisión en directo de las 8as Jornadas de Latinoamérica y Caribe de gvSIG

Las sesiones de ponencias de las 8as Jornadas de Latinoamérica y Caribe de gvSIG, que se celebrarán mañana día 20 de octubre en Montevideo (Uruguay), van a ser retransmitidas en directo a través de internet.
La retransmisión se realizará a través del portal de Vera tv desde el siguiente enlace directo.
8as_j_lac_gvsig-streaming
Podéis consultar toda la información sobre el programa en la web de las jornadas.
Si no podéis acudir podréis seguir las presentaciones en directo.
Y si deseáis acudir, y aún no os habéis registrado, podéis hacerlo desde el mismo portal del evento. Hay aforo limitado. ¡No esperéis al final!

lunes, 26 de septiembre de 2016

La prensa destaca el reconocimiento de la NASA a gvSIG



El pasado viernes un articulo del periódico 20 minutos destacaba el reconocimiento de la NASA al trabajo desarrollado por la Asociación gvSIG con el siguiente titular:
La NASA premia a una entidad española por un proyecto de ciudades inteligentes”.
20 minutos, según los últimos datos, se mantiene firme en el segundo puesto de los diarios más leídos de España con cerca de 1 millón de lectores diarios. No es poca cosa.
La noticia completa se puede leer aquí:
Para un proyecto como gvSIG, sin ninguna multinacional detrás, impulsado por una asociación sin ánimo de lucro y dedicado a desarrollar software libre y compartir conocimiento, salir en la prensa generalista siempre es un hito. Una situación que se está produciendo cada vez más en los últimos tiempos, pero que no deja de alegrarnos en cada ocasión que vemos como gvSIG interesa más allá de los círculos especializados. Una señal más de que el trabajo y esfuerzo de las personas que están implicadas en gvSIG tiene sus frutos.
20_nasa_gvsig_2016
Esperemos que este tipo de noticias también ayuden a que nuestras queridas administraciones apuesten por impulsar la geomática en software libre y abandonen la senda de la dependencia tecnológica, por impulsar a las PYMES locales en lugar de hipotecarse con multinacionales cuyos cuarteles generales están a miles de kilómetros de distancia, y en definitiva por apostar por un nuevo modelo productivo que funciona, es viable y tan solo requiere una miras políticas que entiendan que en el S.XXI la tecnología es un sector fundamental.

lunes, 5 de septiembre de 2016

gvSIG 2.3: Insertar nuevos geoprocesos mediante Scripting


post_geo_minComentábamos el otro día la facilidad de generar geoprocesos con la nueva implementación de librerías de Scripting, los cambios respecto a la versión anterior y mostrábamos un ejemplo de geoproceso.
Ahora vamos a ver cómo podemos integrar nuestro geoproceso en la Caja de Herramientas que tiene gvSIG. Esto nos permitirá acceder a ellos de manera sencilla, además de hacer que formen parte de otras herramientas como el Modelizador o su ejecución mediante gvpy.
El ejemplo, que nos podría servir de plantilla para vuestors scripts sería el siguiente:
from gvsig import *
from gvsig import geom
from gvsig.commonsdialog import *

from gvsig.libs.toolbox import *
from es.unex.sextante.gui import core
from es.unex.sextante.gui.core import NameAndIcon

from es.unex.sextante.gui.core import SextanteGUI
from org.gvsig.geoprocess.lib.api import GeoProcessLocator

class GridPol(ToolboxProcess):

  def defineCharacteristics(self):
        """Definir los parametros de entrada y salida de nuestro proceso. """
        # Fijamos el nombre con el que se va a mostrar nuestro proceso
        self.setName("Grid uniforme dentro de poligonos")

        # Indicamos el grupo en el que aparecera
        self.setGroup("Vectorial")

        params = self.getParameters()
        
        # Indicamos que precisamos un parametro LAYER, del tipo poligono y que es obligatorio
        params.addInputVectorLayer("LAYER","Capa de entrada", SHAPE_TYPE_POLYGON, True)
        
        # Indicamos que precisamos una distancia para el grid
        params.addNumericalValue("DISTANCEGRID", "Distancia Grid",0, NUMERICAL_VALUE_INTEGER)
        
        # Y por ultimo indicamos que precisaremos una capa de salida de puntos.
        self.addOutputVectorLayer("RESULT_POINT", "GirdPol_point", SHAPE_TYPE_POINT)

  def processAlgorithm(self):
        """ Esta operacion es la encargada de realizar nuetro proceso. """
        features=None

        try:

            """
            Recogemos los parametros y creamos el conjunto de entidades asociadas a la capa
            de entrada.

            Se obtendran dos capas en la vista con el mismo tipo de datos.
            ** Una capa es la generada por nosotros desde el script
            ** La otra capa es la gestionada a traves de la Toolbox creada en output_store
            
            """
            params = self.getParameters()
            sextantelayer = params.getParameterValueAsVectorLayer("LAYER")
            distancegrid = int(params.getParameterValueAsDouble("DISTANCEGRID"))
    
            # La capa obtenida es de un tipo especial
            # para facilitar gestionamos su store
            store = sextantelayer.getFeatureStore()
            features = store.features()

            ### Capa 1: Gestionada por el script
            sch = createSchema()
            sch.append("GEOMETRY", "GEOMETRY")
            sch.get("GEOMETRY").setGeometryType(geom.POINT, geom.D2)
            shp = createShape(sch)
            

    
            ### Capa 2: Aprovechando las opciones de la Toolbox
            output_store = self.buildOutPutStore(
                    features.getDefaultFeatureType(),
                    SHAPE_TYPE_POINT,
                    "GridP_points",
                    "RESULT_POINT"
              )
              
            # Progress bar
            self.setRangeOfValues(0, features.getSize())
            n = 0
            
            for feature in features:
                # Incrementamos barra progreso
                self.next() 

                # Proceso
                extent = feature.getDefaultEnvelope()
        
                xmin = extent.getMinimum(geom.DIMENSIONS.X)
                xmax = extent.getMaximum(geom.DIMENSIONS.X)
                
                ymin = extent.getMinimum(geom.DIMENSIONS.Y)
                ymax = extent.getMaximum(geom.DIMENSIONS.Y)
        
                rows = int(ymax-ymin) / distancegrid
                cols = int(xmax-xmin) / distancegrid
                
                x = xmin
                y = ymax
                
        
                for i in range(rows+1):
                    if self.isCanceled():
                        break
                    for j in range(cols+1):
                        pt = geom.createPoint2D(x, y)
                        if feature.geometry().contains(pt):
                            # Puntos contenidos en el poligonos
                            # son agregados a la capa

                            ### Capa 1
                            shp.append(GEOMETRY=pt)
    
                            ### Capa 2
                            newfeature = self.createNewFeature(output_store, feature)
                            newfeature["GEOMETRY"] = pt
                            output_store.insert(newfeature)
    
                            
                        x += distancegrid
                    x = xmin
                    y -= distancegrid

            # Capa 1: Agregamos a la Vista activa
            shp.commit()
            currentView().addLayer(shp)
            
            # Capa 2 se encargara la toolbox de gestionarla
            return True
        
        finally:
            DisposeUtils.disposeQuietly(features)
            print "Proceso terminado %s" % self.getCommandLineName()
            return True


def main(*args):
        # Creamos nuesto geoproceso
        process = GridPol()
        # Lo registramos entre los procesos disponibles en el grupo de "Scripting"
        process.selfregister("Scripting")
        
        # Actualizamos el interface de usuario de la Toolbox
        process.updateToolbox()

        msgbox("Incorporado el script '%s/%s/%s' a la paleta de geoprocesos." % (
                "Scripting",
                process.getGroup(),
                process.getName()
          ), 
          "Proceso registrado"
        )
En la primera parte, defineCharacteristics, incluiríamos el aspecto de la interfaz, podríamos añadir los controles necesarios para capturar los parámetros que nuestro script necesite.
En la segunda parte, processAlgorithm, incluiríamos lo que es nuestro script. Para que la Caja de Herramientas gestione nuestras capas de salida a través del módulo de geoprocesamiento y que se integre mejor con el Modelizador o funcione correctamente cuando sea lanzado desde gvpy, tendrá que cumplir ciertos requisitos y ciertas formas a la hora de generar las capas. En este caso he incluido las dos formas de hacerlo en el mismo geoproceso. Si no nos interesan estas opciones extra, el script será el mismo que ya teníamos creado.
Una vez ejecutado nos aparecerá el siguiente mensaje, confirmando que se ha ejecutado correctamente y que es accesible desde la Caja de Herramientas:
post_geo_insertado
Ahora podemos ir a ejecutarlo

post_geo_caja
Si lo ejecutamos accederemos a la interfaz del geoproceso que hemos creado en la parte de defineCharacteristics de nuestra clase:
post_geo_interfaz
Nos aparecerá la ventana de proceso que hemos programado:
post_geo_status
Y obtendremos el resultado esperado:
post_geo_resultado
Vemos que la salida de capas es multiple. Una capa es la gestionada por la Toolbox, la otra es la gestionada por nosotros directamente en el script.
Esta forma de insertar geoprocesos nos añadirá la opción de poder ejecutarlos mediante gvpy en un script similar al siguiente:
# encoding: utf-8

from gvsig import *
from gvsig.libs import gvpy

def main(*args):

        x = gvpy.runalg("GridPol", "pols_example", "10",ADDLAYER=True, NAME="Grid dentro poligono")
O que forme parte de un proceso en el Modelizador:
post_geo_modelizador
Guardamos el modelo y nos aparecerá en la Caja de Herramientas listo para ser usado:
post_geo_modelo
En este caso cogemos la capa poligonal, le aplicamos el proceso explicado anterior y añadimos un desplazamiento de sus puntos, dando como resultado algo similar a:
post_geo_model_resultado
Como veis, no será complicado crear nuestras propias Cajas de Herramientas, totalmente integradas en gvSIG.
Si estáis interesados en el tema o queréis aportar información o recomendaciones, no dudéis en poneros en contacto con nosotros en las Listas de Usuarios o Desarrolladores. Si hay interés seguiremos intentando generar toda la documentación posible para facilitaros las cosas a la hora de generar vuestros geoprocesos.

jueves, 1 de septiembre de 2016

Camino a gvSIG 2.3: Ejemplo de script con la nueva implementación




geo_gridpol2Ayer hablamos de los cambios en las librerías de Scripting, pero nada mejor para ver algunos de ellos que enseñarlos en un ejemplo.
Da la casualidad que nuestro compañero José Guerrero publicó un script para la generación de una malla de puntos uniforme dentro de cada polígono en una capa designada. Cogiendo su script y aplicando algunos cambios, lo transformé para que pueda ser usado en gvSIG.
Vemos que hacemos uso de la nueva implementación que ya explicamos en otro post, algunas funciones han ampliado su funcionalidad, y en general, funciona como lo hacía anteriormente, aunque por debajo todo sea distinto.
Para ejecutar este script solo es necesario tener una Vista abierta con una proyección por ejemplo EPSG:25830 y con una capa de polígonos seleccionada en esa Vista.
Si quieres cargar el script y probarlo por tu cuenta, debes irte a Herramientas - Scripting - Editor de Scripts. Seleccionamos Nuevo arriba a la izquierda, escribimos un nombre para nuestro script y aceptamos. Ya nos saldrá la pantalla en blanco donde copiar y pegar nuestro script. Para ejecutarlo podemos presionar F5.
# encoding: utf-8

from gvsig import currentLayer, currentView, createSchema, createShape
from gvsig import geom

# Basado en: https://joseguerreroa.wordpress.com/2016/08/31/creando-puntos-espaciados
# -regularmente-dentro-de-los-rasgos-features-de-un-vectorial-tipo-poligono-con-pyqgis/

def main(*args):
    """ Crear grid dentro de polionos con una distancia establecida """
    #Distancia entre puntos
    distancegrid = 5

    # Crear nueva capa
    sch = createSchema()
    sch.append("GEOMETRY", "GEOMETRY")
    sch.get("GEOMETRY").setGeometryType(geom.POINT, geom.D2)
    shp = createShape(sch)
    
    layer = currentLayer()
    features = layer.features()
    
    for feature in features:
        extent = feature.getDefaultEnvelope()

        xmin = extent.getMinimum(geom.DIMENSIONS.X)
        xmax = extent.getMaximum(geom.DIMENSIONS.X)
        
        ymin = extent.getMinimum(geom.DIMENSIONS.Y)
        ymax = extent.getMaximum(geom.DIMENSIONS.Y)

        rows = int(ymax-ymin)/distancegrid
        cols = int(xmax-xmin)/distancegrid
        
        x = xmin
        y = ymax

        for i in range(rows+1):
            for j in range(cols+1):
                pt = geom.createPoint2D(x, y)
                if feature.geometry().contains(pt):
                    # Puntos contenidos en el poligonos
                    # son agregados a la capa
                    shp.append(GEOMETRY=pt)
                x += distancegrid
            x = xmin
            y -= distancegrid
            
    shp.commit() # Guardamos
    currentView().addLayer(shp) # Agregamos a la Vista
Como vemos, queda un script bastante sencillo de leer, sin tener que preocuparnos de rutas o similar. Las proyecciones las coge de la Vista.
geo_gridpol1
Podríamos añadir muchas otras mejoras como la de crear una vista nueva cada vez que se ejecute el script para mostrar resultados currentProject().createView("nueva vista"), preguntar por una capa que no estuviera cargada, etc. Iremos sacando más ejemplos en los que mostrar las nuevas funcionalidades.
En el próximo artículo veremos cómo convertir este script en un geoproceso que aparezca en nuestra Caja de Herramientas, de esta forma lo podríamos tener siempre accesible junto al resto de geoprocesos, dotarle de interfaz, incluirlo en el Model Builder y permitiendo otras funcionalidades como su ejecución desde gvpy.
Interesante crear tu propia caja de herramientas ¿verdad?

miércoles, 31 de agosto de 2016

Camino a gvSIG 2.3: Compatibilidad y cambios en scripts




En el post anterior sobre la nueva integración de las librerías de scripting con la API de gvSIG, comentamos que habíamos realizados cambios importantes en su enfoque a nivel interno pero que, el uso de estas librerías, se mantuviera en lo posible a lo anteriormente desarrollado.
Hemos tenido en cuenta que mucha gente tiene scripts antiguos realizados para la versión 2.2, así que esta nueva implementación es muy parecida a la antigua con algunas excepciones que comentaré más abajo.

¿Qué pasa si tengo un script desarrollado para la versión 2.2?

Una posible solución es activar la compatibilidad de scripts con la 2.2. Esto se puede hacer desde el Scripting Composer, abriendo nuestro script y navegando en la pestaña de Propiedades. Aquí podemos activar la casilla de Compatibilidad con la 2.2. De esta forma cuando gvSIG ejecute este script, utilizará las librerías antiguas de la versión 2.2 de gvSIG.
img22prop

¿Cuáles son los cambios para actualizar mi código?

La siguiente opción sería realizar las modificaciones necesarios para adaptarlo a la versión 2.3. Los cambios no son grandes, así que animo a que optéis por esta opción en vuestros scripts.
Los cambios son menores y voy a ir explicando los más significativos para que podáis localizarlos y modificarlos.
También será útil si venís de programar en la 2.2, veréis la nueva forma de hacer las cosas. Como ya he dicho, no os preocupéis, los cambios son pequeños.
Imports
* 2.2: En la anterior versión existían varias librerías como gvsig, geom, commonsdialog... a las cuales se les hacia referencia directamente con un import:
import gvsig
import geom 
import commonsdialog
* 2.3: En la nueva versión hemos querido desarrollar todo dentro de una librería única que fuera gvsig. Estos módulos siguen existiendo solo que su acceso de ha modificado, siendo:
import gvsig
import gvsig.geom
import gvsig.commonsdialog
Podemos importarlo de diferente forma para que se adapte mejor al script que ya tengamos hecho, dependiendo a cómo lo teníamos hecho, siendo las diferentes opciones por ejemplo:
import gvsig.geom
ó
from gvsig import geom
ó
from gvsig.geom import *
Creación de capas: Tipo de geometrías
* 2.2: A la hora de crear capas, siempre tenemos que crear primero el esquema (FeatureType) de nuestra capa. En la anterior versión establecíamos qué tipo de geometría iba a utilizar la capa a la hora de generar la misma, por ejemplo, en el createShape().
* 2.3: En la nueva versión hemos simplificado este sistema. El tipo de geometría se establece solo en el esquema.
from gvsig import *
from gvsig.geom import *

def main(*args):

    fty = createFeatureType() #es lo mismo que createSchema()
    fty.append("GEOMETRY", "GEOMETRY")
    fty.get("GEOMETRY").setGeometryType(POINT, D2)
    shp = createShape(fty)
Las constantes POINT y D2 vienen de la librería geom.
Si los import fueran diferentes:
import gvsig
from gvsig import geom

def main(*args):

    fty = gvsig.createFeatureType()
    fty.append("GEOMETRY", "GEOMETRY")
    fty.get("GEOMETRY").setGeometryType(geom.POINT, geom.D2)
    shp = gvsig.createShape(fty)
Edición de entidades
* 2.2: En la versión anterior podíamos poder en edición una entidad directamente y modificarla. Por limitaciones en la nueva implementación esto no es posible ahora. Seguimos una aproximación más cercana a Java.
* 2.3: La forma de realizar una modificación en una capa y en sus entidades sería a través de una entidad editable que obtenemos de la entidad principal, y que luego actualizamos sobre el featureSet y no sobre la capa, como en la anterior versión:
from gvsig import *
from gvsig import geom

def main(*args):

    layer = currentLayer()
    features = layer.features()

    layer.edit() #Ponemos la capa en edición

    for i in features:
       c = i.getEditable() #Obtenemos una entidad editable
       c.set("NAME", "Modified_4") #Modifacmos la entidad
       #Actualizamos entidad sobre el featureSet
       features.update(c) 

    layer.commit() #Guardamos la capa
Crear una geometría de tipo punto
* 2.2: En la anterior versión utilizábamos para crear un punto la función createPoint(x, y)
* 2.3: Dadas las mejores en la librería de geometrías que hemos realizado, hemos modificado este método. Tenemos varias formas de llamarlo. Ambas se encuentran dentro del módulo gvsig.geom:
Una función que hemos incluido para imitar el comportamiento de la antigua:
p1 = geom.createPoint2D(x, y)
O la nueva que permite mayor versatilidad a la hora de generar puntos, teniendo que pasar como parámetro la dimensión de este punto:
p2 = geom.createPoint(geom.D2, x, y)
o una opción más genérica, en la cual primero crearíamos la geometría de punto vacía, y luego tendríamos que establecer sus coordenadas:
p3 = geom.createGeometry(geom.POINT)
p3.setX(x)
p3.setY(y)
Ambos obtienen como resultado un geometría de tipo punto de dimensiones 2D.
Valores devueltos por las funciones de commonsdialog
* 2.2: En la anterior versión, los objetos devueltos por la librería commonsdialog referentes a la obtención de rutas, se hacían excesivamente complicados, devolviendo arrays de java.io.File o similar.
* 2.3: En la nueva versión, hemos simplificado este retorno de valores. Si la multiseleción está establecida en False, devolverá un único String correspondiente a la ruta. Si la función no tiene parámetro multiselection o lo tiene establecido como True, devolverá una lista de String con las rutas correspondientes.
option = "OPEN_FILE"
fc = commonsdialog.filechooser(option, 
                                title="", 
                                initialPath=None, 
                                multiselection=False, 
                                filter = None, 
                                fileHidingEnabled=True, 
                                root=None)
print "filechooser:", fc
fc = commonsdialog.filechooser(option, 
                                title="", 
                                initialPath=None, 
                                multiselection=True, 
                                filter = None, 
                                fileHidingEnabled=True, 
                                root=None)
print "filechooser:", fc
Salida por consola:
filechooser: C:\Users\Oscar\values.txt
filechooser: [u'C:\\Users\\Oscar\\input1.csv', u'C:\\Users\\Oscar\\input2.txt']
Si seguimos encontrando diferencias de compatibilidad las iremos añadiendo al post.
Dado que hay muchos cambios en las librerías y en funcionalidades, os animamos a que nos informéis de errores que detectéis en estas nuevas herramientas para Scripting en las Listas de Usuarios o Desarrolladores

martes, 30 de agosto de 2016

Camino a gvSIG 2.3: Animaciones


Entre las novedades relacionadas con 3D en gvSIG 2.3 encontramos la posibilidad de realizar animaciones.
Los usuarios de gvSIG contarán con un gestor de animaciones que permitirá ir guardando los encuadres que generarán la animación.
Os dejamos con un vídeo sobre el funcionamiento de esta nueva herramienta:

domingo, 28 de agosto de 2016

IDE del Instituto de Patrimonio Cultural de España

IPCE_01
En este post vamos a presentaros la Infraestructura de Datos Espaciales en software libre para la gestión del Patrimonio que ha puesto en marcha la Asociación gvSIG, gracias a la tecnología gvSIG Online.
El IPCE, Instituto del Patrimonio Cultural de España, es una institución dependiente de la Dirección General de Bellas Artes y Bienes Culturales y de Archivos y Bibliotecas del Ministerio de Educación Cultura y Deporte, dedicada a la investigación, conservación y restauración de los bienes culturales que conforman el patrimonio histórico español. Para ello integra en su personal especialistas de diversas disciplinas: arquitectos, arqueólogos, etnógrafos, restauradores, físicos, geólogos, químicos, biólogos, documentalistas, informáticos, fotógrafos, bibliotecarios, archiveros y conservadores, entre otros.
En la práctica eso se traduce en una serie de tareas, proyectos y actividades alrededor de una información que en un amplio porcentaje de ocasiones tiene una componente geográfica. Una información muy valiosa y que, hasta la puesta en marcha de la IDE, era casi imposible reutilizar al no existir un mecanismo que permitiera no sólo tenerla localizada, sino también compartirla, combinarla e interoperar con ella para poder aprovechar todo el potencial de esta base de datos de conocimiento de carácter espacial.
La puesta en marcha de la IDE del IPCE tiene su punto de partida en un proyecto de investigación relacionado con la conservación preventiva. Se puede resumir que la conservación preventiva es una estrategia de conservación del patrimonio cultural que propone un método de trabajo sistemático para identificar, evaluar, detectar y controlar los riesgos de deterioro de los objetos, colecciones, y por extensión cualquier bien cultural, con el fin de eliminar o minimizar dichos riesgos, actuando sobre el origen de los problemas, que generalmente se encuentran en los factores externos a los propios bienes culturales, evitando con ello su deterioro o pérdida y la necesidad de acometer drásticos y costosos tratamientos aplicados sobre los propios bienes.
Los esfuerzos en la aplicación de métodos de trabajo de conservación preventiva se centran en una serie de aspectos en los que se concentran la mayor parte de los riesgos de deterioro que amenazan a los bienes culturales. Entre los aspectos que contempla la Conservación Preventiva encontramos algunos que tienen una especial relevancia en cuanto a la necesidad de implantar una Infraestructura de Datos Espaciales; destacan los siguientes:
  • Daños o pérdidas causados por episodios catastróficos como incendios, terremotos o inundaciones.
  • Daños causados por condiciones ambientales inadecuadas entre las que se incluyen los factores microclimáticos, las radiaciones asociadas a la luz y los contaminantes atmosféricos.
  • Daños causados por el biodeterioro, generalmente asociados a condiciones ambientales inadecuadas y deficiencias en la disposición y mantenimiento de las instalaciones.
En definitiva estos aspectos se concretan en el análisis de una información como la relativa a climatología y condiciones ambientales que es susceptible de ser analizada mediante Sistemas de Información Geográfica. Se trata además, en la mayoría de los casos, de información viva y variante que requiere de una clasificación temporal.
IPCE_gvSIG_03
Es evidente que la complejidad en la conservación de ciertos bienes culturales, como los centros históricos de las ciudades, los paisajes culturales, el arte rupestre y los bienes culturales ligados a ecosistemas naturales, o los componentes del patrimonio inmaterial, exigen herramientas específicas y complejas, muy diferentes a las desarrolladas hasta ahora, para la aplicación de estrategias de conservación preventiva. Es en este aspecto donde las Infraestructuras de Datos Espaciales pueden convertirse en una herramienta o tecnología de primer orden, sumando a la modernización de la gestión del Patrimonio Cultural.
Así, dentro de las tareas relacionadas con la conservación preventiva existía un proyecto de investigación para la deducción de índices de riesgo climático en relación con la conservación de los bienes culturales. Estudiar diferentes parámetros climáticos como la temperatura, la humedad o la pluviometría, etcétera, su variabilidad a lo largo del ciclo anual y poder cruzar las distintas entradas de información geográfica, era la base del proyecto que dio inicio a la puesta en marcha de la Infraestructura de Datos Espaciales. Para ello, además de las herramientas habituales de una IDE, se desarrolló un módulo de gestión de series temporales de datos, que permite por un lado añadir a la IDE cualquier serie de datos con el atributo tiempo y, por otro lado poder realizar la consulta de cualquier capa de climatología relevante para la conservación de los bienes culturales, en relación con una fecha concreta.
IPCE_gvSIG_04
gvSIG Online, la tecnología utilizada en la IDE del IPCE, es una plataforma integral para la puesta en marcha, gestión y explotación de Infraestructuras de Datos Espaciales. Internamente está formado por una serie de componentes de software, todos ellos con licencia libre, que permiten disponer de una IDE completa. La IDE del IPCE tiene tanto geoportales e información privada como algunos geoportales públicos, relacionados como ya se ha comentado con proyectos de investigación de conservación del patrimonio en relación con distintas variables climáticas. Una de las características que hacen diferente a esta IDE respecto a las implantadas por otras organizaciones como institutos geográficos, con información que es actualizada en períodos de tiempo grandes, es la relacionada con la variabilidad de proyectos que se generan y la utilización de datos que varían constantemente.
IPCE_gvSIG_02
La experiencia en la aplicación de estas tecnologías al ámbito de la conservación es extrapolable a otros organismos responsables del mantenimiento del Patrimonio Cultural y abre un nuevo campo de aplicación de la geomática hasta ahora poco explorado. Una solución que desde la Asociación gvSIG ofrecemos para todas aquellas organizaciones que requieran implantar su IDE / SIG Corporativo y que apuesten por todas las ventajas que aporta el software libre.
Podéis dar un vistazo a la parte pública de la IDE del IPCE aquí: https://ipce.gvsigonline.com/gvsigonline/
Y si queréis ver un vídeo-webinar sobre gvSIG Online...