gvSIG blog

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.

Ayer 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.

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?