gvSIG 2.3: Insertar nuevos geoprocesos mediante Scripting

Comentá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:

Ahora podemos ir a ejecutarlo

Si lo ejecutamos accederemos a la interfaz del geoproceso que hemos creado en la parte de defineCharacteristics de nuestra clase:

Nos aparecerá la ventana de proceso que hemos programado:

Y obtendremos el resultado esperado:

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:

Guardamos el modelo y nos aparecerá en la Caja de Herramientas listo para ser usado:

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:

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.

by Óscar Martínez