gvsig Documentation Publicación 0 Oscar

(1)

Publicación 0

Oscar

13 de December de 2016

(2)

(3)

1. Documentación de Scripting en gvSIG 2.3 1

1.1. Tabla de contenidos . . . 1

1.2. Enlaces . . . 115

1.3. Índices . . . 116

2. gvSIG 2.2.0. Guía de inicio rápido para el desarrollador 117 2.1. Introducción . . . 117

2.2. Usar gvSIG frente a modificar gvSIG . . . 119

2.3. gvSIG basic architecture . . . 119

2.4. Herramientas de construcción . . . 124

2.5. Building our first plugin . . . 124

2.6. Conclusiones . . . 148

2.7. Documentacion relacionada . . . 148

3. gvSIG 2.3.1. Guía de inicio rápido para el desarrollador 151 3.1. Introducción . . . 151

3.2. Usar gvSIG frente a modificar gvSIG . . . 153

3.3. Arquitectura básica de gvSIG . . . 153

3.4. Herramientas de construcción . . . 158

3.5. Construyendo nuestro primer plugin . . . 158

3.6. Conclusiones . . . 187

3.7. Documentacion relacionada . . . 187

4. org.gvsig.fmap.dal 189 4.1. Tabla de contenidos . . . 189

5. Cómo contribuir en gvSIG 233 5.1. Tipos de contribuciones . . . 233

5.2. Aportar un paquete al repositorio de paquetes de gvSIG . . . 233

5.3. Contribuciones y parches al código de gvSIG . . . 235

5.4. Proyectos oficiales . . . 238

5.5. Normas de codificación y desarrollo . . . 243

6. Links 245

7. gvSIG 2.3 247

8. gvSIG 2.2 249

(4)

(5)

Documentación de Scripting en gvSIG 2.3

1.1 Tabla de contenidos

1.1.1 Introducción

Qué es el Módulo de Scripting

El Módulo de Scripting es un módulo de programación integrado completamente en gvSIG 2.

Este módulo se integró desde las versiones 2.x de gvSIG, y ha sufrido importantes mejoras en gvSIG 2.3.

Qué necesitas

Para seguir esta guía tan solo necesitas tener instalado la versión de gvSIG 2.3. El Scripting Framework o Módulo de Scripting vienen instalados por defecto.

La última versión disponible de gvSIG 2 que podrás encontrar en: http://www.gvsig.com/es/productos/gvsig- desktop/descargas

También será necesario tener instalado el paquete de Scripting Composer Tools. Este paquete es un conjunto de herramientas desarrollado para facilitar la tarea del desarrollador. Incluye herramientas de autocompletado, code navigator, la herramienta de interfaces visuales Abeille, entre otros. Se podrán instalar directamente desde el Administrador de Complementos.

Iremos a Herramientas → Administrador de Complementos y seleccionaremos Instalación estándar.

Haremos una busqueda de las Composer Tools:

Cuando la instalación a finalizado, abriendo el Herramientas → Scripting → Editor de Scripts, podremos comprobar que aparece la carpeta ScriptingComposerTools y que se ha instalado correctamente.

Es necesario reiniciar gvSIG para su uso. Si volvemos a abrir el Editor de Scripts, veremos que aparecen una serie de botones extra en la barra de Herramientas:

Qué nos permite

Este módulo de programación nos dará la oportunidad programar nuestras propias herramientas y extensiones para gvSIG.

Los scripts los podremos modificar, adaptar, intercambiar y desarrollar de una manera sencilla, y lo más importante, rápida.

(6)

(7)

(8)

Una de las ventajas es que dada la facilidad del lenguaje Python, no será necesario tener conocimientos extensos de programación ni de cómo funciona al completo la arquitectura de gvSIG para poder desarrollar la herramienta que necesitemos.

Las posibilidades son infinitas, nos permitirá: - Automatizar tareas - Añadir funcionalidades - Crear nuevos geoprocesos - Personalizar gvSIG - Creación de extensiones (Plugins) - Uso de la API de gvSIG: tratamiento de espaciales, conexiones de datos, generación de mapas, etc.

Qué lenguaje utilizamos

El lenguaje principal en el que hemos centrado el desarrollo es Jythonhttp://www.jython.org/, aunque también se pueden ejecutar scripts en Groovy, R..

Jython es una implementación de Python realizada en Java.

Esta implementación nos permite trabajar con la API de gvSIG (aplicación realizada en Java) usando scripts utilizando la sintaxis de Python, facilitando mucho el desarrollo y ejecución de estos, solo necesitando tener instalado gvSIG para poder programar.

Esto nos da unas ventajas enormes, por un lado, Python es un lenguaje muy sencillo de aprender, por otro lado, no se necesita de una compilación previa con un IDE externo, sino que la compilación del código necesario se realiza sobre la marcha, cada vez que ejecutamos nuestro script. Esto nos permite realizar modificaciones en nuestros script e irlo probando mientras tenemos gvSIG abierto.

Además, tiene compatibilidad con muchas de las librerías de Python existentes, y todas (o mayoría) de Java.

Cómo acceder al Módulo de Scripting

Una vez instalado gvSIG 2 ya lo podemos abrir. Para acceder a este módulo de programación lo haremos a través del menú Herramientas → Scripting. Aquí nos encontraremos con 3 opciones:

Scripting Launcher

(9)

Se trata de un lanzador de scripts, una lista con accesos directos a los scripts que tenemos. Según vayamos creando y almacenando nuestros scripts, estos pasaran a formar parte de esta lista que podremos tener abierta y accesible para ejecutar un script que necesitemos en cualquier momento con un doble click. Es muy cómodo si preparamos scripts para ejecutarlos mientras estemos trabajando, una forma rápida de tenerlos a mano.

Scripting Composer

Es la pantalla principal de este módulo. Aquí podremos crear, ordenar y almacenar todos nuestros scripts.

Los botones principales: Nuevo, Abrir, Guardar, Guardar y Ejecutar, Cerrar.. Una vez creemos un fichero nuevo, podremos escribir nuestro código.

La ejecución del script aparecerá reflejada en la consola que se sitúa en la parte inferior,

Jython Console

Es una consola que nos permitirá ejecutar código directamente, ejecutándose línea a línea. Nos permite consultar variables y ver cómo se van modificando.

Otra función interesante es que nos ofrecerá una ayuda de los comandos que están disponibles según el código que estemos escribiendo, o qué tipo de métodos tienen disponibles las diferentes clases de gvSIG.

(10)

Librerías de gvSIG para Scripting

Hemos creado una librería escrita en Jython denominada gvsig. Su función es inyectar métodos extra en estas clases de Java ya existentes en la API de gvSIG y ampliar mediante nuevas funciones la potencia y facilidad de uso de este módulo.

Su objetivo es el disminuir el número de líneas requeridas para realizar ciertas operaciones y hacer accesible la API de gvSIG de una manera más sencilla desde Jython.

Las librerías Java de las que se compone gvSIG están totalmente accesibles desde nuestros scripts en Jython, siendo posible sin ninguna restricción en el acceso a ellas y en la creación de extensiones de la misma forma que si las hiciéramos directamente en Java.

Organización de la librería gvsig

El Módulo de Scripting viene con diversas librerías:

gvsig: pertenecen las funciones principales de gvSIG, principalmente para el acceso y manejo de datos. Con- tiene funciones útiles y los métodos inyectados en las clases de gvSIG. También contiene el resto de módulos que explicamos.

gvsig.commonsdialog: encargada de la generación de ventanas, desde a mensajes de alerta a rutas de ficheros.

gvsig.geom: contiene todas las funciones relacionadas con las geometrías

Además, hemos incluido otras clases importantes que nos ayudarán mucho la generación de scripts:

gvsig.libs.formpanel.FormPanel: Esta clase nos ayudará en la generación de script con interfaces visuales

gvsig.libs.gvpy: Librería para la ejecución de geoprocesos desde Scripting

(11)

gvsig.libs.toolbox.ToolboxProcess: Clase para la creación de geoprocesos que serán añadidos a la Toolbox y podrán ser utilizados desde el Modelizador.

gvsig.libs.load_project.load_project(): Función para abrir un proyecto en gvSIG desde un fichero.

etc

Es recomendable importar tan solo las librerías necesarias para la ejecución del script.

Si nuestro script contiene otras librerías propias que también hemos programado, al realizar su importación podemos forzar la recarga de estas librerías (sino los cambios no se verán reflejados) utilizando la función reload(). La forma correcta de hacerlo sería:

import lib reload(lib)

Creación de un script

Para crear un script nuevo, trabajaremos en el Scripting Composer presiona el botón de Nuevo situado arriba a la izquierda, o en Archivo → Nuevo se nos abrirá una pantalla sobre el tipo de script a crear.

En esta pantalla debemos escribir el nombre y descripción de lo que vayamos a crear. En el tipo de archivo podremos elegir qué crear. Las opciones son:

(12)

Script: Programa con código lineal que podremos ejecutar.

Dialog: Programa con código y una interfaz visual. (No recomendado, para scripts con interfaz visual usaremos también el tipo script)

Project: Aún no habilitado, para futuras versiones.

Folder: Crea una carpeta en nuestra lista de “Scripts de usuario”.

Podemos elegir el lenguaje de programación que prefiramos. Los lenguajes soportados son: - ECMAScript - Python:

es el lenguaje en que tenemos centrado el desarrollo - Groovy - R - Scala

En Save on podremos elegir en qué carpeta guardamos nuestro nuevo script. Las dos últimas cajas de texto son sobre información del Autor y Versión.

Hacemos click en “Accept”. Esto creará nuestro nuevo script en blanco, que aparecerá abierto para su edición. Veremos que aparece nuevo en nuestro listado de scripts de usuario y se abre una pestaña con el nombre del script. En esta pestaña un asterisco aparecerá indicando si el script contiene cambios que no han sido guardados. Debajo aparece nuestro código que por defecto trae una plantilla con la estructura básica, y debajo del todo encontramos la salida por consola.

Los scripts creados se almacenan en la carpeta de gvSIG C:\Users\*\gvSIG\plugins\org.gvsig.scripting.app.extension.

De forma similar en la /home/ de Linux. Ahora nos disponemos a escribir nuestro primer script. El ejemplo que nos viene por defecto es totalmente válido:

Lista 1.1: primer_script.py

1 # encoding: utf-8

2

3 import gvsig

4

5 def main(*args):

6

7 #Remove this lines and add here your code

8

9 print "hola mundo"

10 pass

En primer lugar, realiza una importación de la librería que vamos a utilizar, la librería de scripting gvsig, y luego define dentro de la función principal main(), el comando print que hará salir nuestro valor por consola.

En Scripting en gvSIG, la función que se va a ejecutar por defecto será siempre la función main(), así que debemos de introducir todo nuestro código en esta función.

Nota: Todos nuestros scripts deben de contener la función main() para su correcta ejecución. No será obligatorio si van a ser usados como librerías.

Para ejecutar un script guardando y ejecutando o directamente presionaremos el botón y veremos su ejecución por consola.

(13)

(14)

Podemos comprobar que la salida por consola es de “hola mundo”, siendo este el objetivo que buscábamos. Con esto hemos ejecutado nuestro primer script con éxito.

Esta estructura es la estructura básica de un script en gvSIG 2.3.

Si abrimos ahora el Scripting Launcher, en el menú de Scripting, veremos que ya aparece nuestro script en el nuevo listado.

Si queremos comprobar nuestros scripts en el disco duro estarán en la carpeta:

En una vesión instalable en Windows: C:\Users\NombreUsuario\gvSIG\plugins\org.gvsig.scripting.app.extension\scripts

En una vesión portable en Windows: \gvSIG_carpeta_instalacion\home\gvSIG\plugins\org.gvsig.scripting.app.extension\scripts En esta carpeta podemos copiar o pegar los scripts, fijándonos en copiar ambos archivos .py y .inf.

Nota: Lo recomendable es generar los scripts dentro de su propia carpeta. Esto nos permitirá usarlos como módulos dándonos varias opciones: usar ficheros autorun.py (autoejecutable al inicio de gvSIG), fichero __init__.py (nos per- mitirá trabajar como si fuera un módulo permitiéndonos importar librerías que estén en la misma carpeta) y la creación de paquetes de Scripts

Generando paquetes de scripts

Una vez hemos creado un script en su propia carpeta con todo lo necesario, podemos generar un paquete de gvSIG .gvspkgpara enviarlo o subirlo. Con este paquete podremos realizar la instalación del script desde el Adminis- trador de Complementos. Su uso es muy intuitivo.

La herramienta se encuentra en el Scripting Componser, en el menú Herramientas → Paquete de script.

Seleccionamos la carpeta que contiene nuestra extensión:

Establecemos las propiedades del paquete:

Las opciones de salida:

La ruta será similar a esta: gvSIG-desktop-2.3.0-2441-RC2-win-x86_64\install\gvSIG-desktop-2.3.0-ExportadorCapas-1.0.0-0-testing-all-all-j1_7.gvspkg.

Y terminado, ya aprecerá nuestro extensión en formato .gvspkg para poderse instalar desde el Administrador de Complementos

1.1.2 Modelo de objetos simplificado

Aquí podemos ver un esquema con los componentes de uso más común desde scripting, la relación entre ellos y cómo podemos acceder a ellos desde nuestro script. Además podemos navegar a la información de la clase Java pulsando sobre el componente.

Nota: Desarrolladores Java y usuarios con conocimientos sobre UML. El diagrama y comentarios está pensado para que sea lo más entendible posible por un usuario sin conocimientos de java ni UML, no para ser estricto con la nomenclatura UML.

Cómo interpretar el diagrama En el diagrama anterior podemos ver:

(15)

(16)

(17)

(18)

(19)

Cajas en amarillo, que representan a objetos que podemos encontrarnos y con los que podemos trabajar.

Cajas en verde, nos indican acciones que podemos realizar desde nuestro script. Por ejemplo, podemos ver:

Lo interpretaremos como que disponemos de una función, currentProject(), que podemos ejecutar desde nuestro script para obtener el objeto con el que está relacionada, en este caso el project. Para los elementos etiquetados como función precisaremos haber importado el modulo gvsig:

from gvsig import *

Cajas en azul, nos indica que se trata de una entidad abstracta. Nunca encontraremos objetos de este tipo.

Hacen referencia de forma genérica a un grupo de objetos con características comunes; por ejemplo, tendremos unDocumentque agrupa las características comunes deViewDocument,TableDocumentoLayoutDocument.

En el diagrama podemos encontrarnos, por ejemplo:

Aquí tendríamos una entidadFFrameabstracta, no nos encontraremos nunca objetos de este tipo, lo que nos encontraremos será objetos de tipoFFrameView,FFramePictureoFFrameText, y nos indica que todos los objetos concretos relacionados conFFrametendrán un conjunto de atributos y operaciones comunes.

Asociaciones entre objetos, que nos indican qué a partir de un objeto podemos obtener otro o un conjunto de otros. Por ejemplo:

Nos indica que si disponemos de un objetoLayoutDocument, podemos obtener el objetoLayoutContextinvocando a la operación o método getLaypoutContext:

laypoutContext = layoutDocument.getLaypoutContext()

(20)

1.1.3 Modelo de clases simplificado

Plugins y acciones Plugins

Acciones

Proyecto y documentos Mapcontrol

MapContext Geometrías

Acceso a datos (DAL)

1.1.4 Módulo commonsdialog

Funciones principales

msgbox(message

[

, title=”“, meesageType=IDEA, root=None

]

⁾

Shows a message dialog with ok button only.

Parámetros

message(str) – text to present in the dialog title(str) – title of the dialog

messageType(int) – type of icon to use.

root(DefaultFrame or None) – Frame reference

inputbox(message

[

, title=”“, messageType=IDEA, initialValue=”“, root=None

]

⁾

Shows a input dialog.

Parámetros

(21)

messageType(int) – type of icon to use.

initialValue(str) – Initial value of the inputbox root(DefaultFrame or None) – Frame reference Devuelve Return text in the input box

Tipo del valor devuelto str

confirmDialog(message

[

, title=”“, optionType=YES_NO, messageType=IDEA, root=None

]

⁾

Create a message dialog with options button Parámetros

optionType(int) – bottons to show messageType(int) – type of icon to use.

filechooser(option

[

, title=”“, initialPath=None, multiselection=False, filter = None, fileHidingEna- bled=True, root=None

]

⁾

Allows configuration parameters to filechooser dialogs Parámetros

option (int) – file chooser selection mode. Allowed values: OPEN_FILE, OPEN_DIRECTORY, SAVE_FILE

title(str) – Window title

initialPath(str) – Initial path to the directory to open in the dialog multiselection(boolean) – Allow select more than one object.

filter(List of Strings) – list of acepted extension files (“jpg”, “png”, “gif”) fileHidingEnabled(boolean) – True if hidden files are not displayed

Devuelve Selected path or list of paths

openFileDialog(

[

title=’‘, initialPath=None, root=None

]

⁾

Shows a window dialog to choose one file.

Parámetros

title(str) – Window title. Default ‘’

initialPath(str) – Initial path to open in window dialog openFolderDialog(

[

]

⁾

Shows a window dialog to choose one folder.

Parámetros

initialPath(str) – Initial path to open in window dialog saveFileDialog(

[

]

⁾

Shows a window dialog to choose one file.

Parámetros

(22)

initialPath(str) – Initial path to open in window dialog getJavaFile(path)

Returns a java File using parameter path. If path doesn’t exists looks for user home folder and if can not find it, returns path will be gvSIG instance directory.

Parámetros path (str) – String-path.

Devuelve Return java.io.File

Constantes en la librería

Constantes que aparecen en la librería y usaremos en diferentes funciones:

*messageType options*

FORBIDEN = 0 IDEA= 1 WARNING= 2 QUESTION= 3

*Confirmdialog optionType Options*

YES_NO = 0

YES_NO_CANCEL = 1 ACCEPT_CANCEL = 2 YES = 0

NO = 1 CANCEL = 2

*filechooser options*

OPEN_FILE = 0 OPEN_DIRECTORY = 1 SAVE_FILE = 2

*filechooser selectionMode*

FILES_ONLY = JFileChooser.FILES_ONLY

DIRECTORIES_ONLY = JFileChooser.DIRECTORIES_ONLY

Uso

En el módulo de commonsdialog gestiona las ventanas emergentes que aparecen en gvSIG. Por ejemplo, si queremos mostrar un avisa al usuario usaremosmsgbox(): o si queremos preguntar por algún valor al usuario que ejecute el script, podemos usar la funcióninputbox()la cual devolverá el texto que escriba el usuario en la caja de texto que aparecerá en pantalla.

Para importar la librería lo haremos mediante:

import gvsig.commonsdialog

o:

from gvsig import commonsdialog o:

(23)

from gvsig.commonsdialog import *

Por ejemplo:

1 from gvsig import commonsdialog

2

4

5 commonsdialog.msgbox("Bienvenido a gvSig","Welcome", commonsdialog.IDEA)

El tipo de mensaje lo establecemos en el parámetro messageType como podemos ver enmsgbox()y estos tipos se encuentran almacenados en constantes dentro del módulo commonsdialog.

O depende de cómo lo importemos.

Lista 1.2: msgbox.py

1 from gvsig.commonsdialog import *

2

4

5 msgbox("Bienvenido a gvSIG", "Welcome", IDEA) Dando como resultado una ventana:

Depende del tipo de aviso que seleccionemos mostrará diferentes iconos en la ventana:

WARNING:

FORBIDEN:

(24)

QUESTION:

Tipos de diálogos

Diferentes tipos de diálogos:

from gvsig import commonsdialog from gvsig.commonsdialog import *

def main(*args):

message = "Prueba"

mb = commonsdialog.msgbox(message, title="", messageType=IDEA, root=None) print "msgbox:", mb

ib = commonsdialog.inputbox(message, title="", messageType=IDEA, initialValue="", root=None) print "inputbox:", ib

cd = commonsdialog.confirmDialog(message, title="", optionType=YES_NO, messageType=IDEA, root=None) print "confirmDialog:", cd

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

ofiled = commonsdialog.openFileDialog(title='', initialPath=None, root=None) print "openFileDialog:", ofiled

ofolderd = commonsdialog.openFolderDialog(title='', initialPath=None, root=None) print "openFolderDialog:", ofolderd

sfd = commonsdialog.saveFileDialog(title='', initialPath=None, root=None) print "saveFileDialog:",sfd

Msgbox:

Inputbox:

Confirm Dialog:

File chooser:

File chooser with multiselection:

(25)

(26)

Open file dialog:

Open folder dialog:

Save file dialog:

Salida por consola:

msgbox: None inputbox:

confirmDialog: 0

filechooser: D:\gvdata\countries027.geojson

filechooser: [u'D:\\gvdata\\countries024.geojson', u'D:\\gvdata\\countries025.geojson', u'D:\\gvdata\\countries026.geojson',

u'D:\\gvdata\\countries027.geojson', u'D:\\gvdata\\countries028.geojson', u'D:\\gvdata\\countries029.geojson', u'D:\\gvdata\\countries030.geojson']

openFileDialog: [u'D:\\gvdata\\countries028.geojson']

openFolderDialog: [u'D:\\gvdata\\GISofThrones\\GoTRelease']

saveFileDialog: [u'D:\\gvdata\\newfile.shp']

1.1.5 Cargando capas

loadShapeFile(shpFile, **parameters):

Add an existing shape file to the view. Returns Layer shape file Parámetros

shpFile– absolute file path to the shape

(27)

CRS(string) – projection code

gvViewName(string) – name of the view where to be loaded gvLayerName(string) – name of the layer inside gvsig Type shpFile: string

Devuelve shape

loadRasterFile(filename, **parameters):

Add an existing raster file to the view. Returns Layer Raster file.

Parámetros

filename(str) – absolute file path to the raster CRS(string) – projection code

gvViewName(string) – name of the view where to be loaded gvLayerName(string) – name of the layer inside gvsig Devuelve raster layer

loadDBF(filename):

Open an existing dbf file

Parámetros filename (str) – absolute file path to the DBF file Devuelve dbf

(28)

Recursos en rutas relativas: getResource()

En muchas ocasiones es necesario hacer referencia a ficheros que tengamos dentro de nuestro módulo, es decir, obtener la ruta completa de un fichero a partir de la ruta relativa en la que se encuentre nuestro script, independientemente de donde este instalado o del sistema. Para ello nos ayudamos de la función os.path.dirname(__file__) que devuelve la ruta de la carpeta de nuestro script en ejecución.

En este caso, __file__, nos devuelve la ruta del script en ejecución:

import gvsig def main(*args):

print __file__

En mi caso la ruta es:

/home/osc/gvsig-devel/master_scripts/testing_getResource.py

Con la función os.path.dirname() lo que hacemos es sacar el directorio donde se encuentra el script. Ejemplo de uso:

# encoding: utf-8 import os

import gvsig

"""Obtener ruta absoluta de ficheros en la carpeta de ejecucion del script"""

(29)

path_script = os.path.dirname(__file__) print "Path script: ", path_script print "Ruta relativa: data/fichero.xx"

print "Ruta absoluta: ", os.path.join(path_script, "data", "fichero.xx")

Salida por consola será:

Path script: c:\gvdevel\gvsig\gvSIG-desktop-2.3.0-2441-RC2-win-x86_64\home\gvSIG\plugins\org.gvsig.scripting.app.mainplugin\scripts Ruta relativa: data/fichero.xx

Ruta absoluta: c:\gvdevel\gvsig\gvSIG-desktop-2.3.0-2441-RC2-win-x86_64\home\gvSIG\plugins\org.gvsig.scripting.app.mainplugin\scripts\data\fichero.xx De esta forma estaríamos accediendo a la carpeta /datos/ dentro de nuestro módulo.

Hemos incorporado en la librería de gvsig una función gvsig.getResource() que nos ayuda a realizar esta operación de forma más sencilla.

Por ejemplo:

# encoding: utf-8

x = gvsig.getResource(__file__,"testing.py") print "path: ", x

print "type: ", type(x)

Podemos comparar la ruta por consola:

(30)

path: /home/osc/gvsig-devel/master_scripts/testing.py type: <type 'unicode'>

Pudiendo añadirle tantos parámetros como carpetas sea necesario recorrer:

# encoding: utf-8

x = gvsig.getResource(__file__,"Game","data","testing.py") print "path: ", x

Muestra por consola la ruta:

path: /home/osc/gvsig-devel/master_scripts/Game/data/testing.py type: <type 'unicode'>

Podemos usar la función para otro tipo de rutas asegurándonos que será correcta independientemente del sistema:

x = gvsig.getResource("/home/osc/temp/","test1.dbf") print "path: ", x

Función de carga: loadLayer

Las funciones posteriores se apoyan todas en una función principal denominada loadLayer.

Ejemplo de uso para un fichero raster:

layer = loadLayer('Gdal Store', crs=getCRS("EPSG:3042"),uri=File(r"C:\temp\mdt20_3_etrs89.tif").toURI(),gvViewName=currentView())

Capas Vectoriales

Para cargar capas vectoriales usaremos la función loadShapeFile(). Esta es una función de apoyo que llama a la función createLayer() más genérica.

Ejemplo:

from gvsig import * from java.io import File def main(*args):

# Get resource path

shape_path = os.path.join(os.path.dirname(__file__),"data","jaen.shp")

# loadShapeFile function s1 = loadShapeFile(shape_path)

# LoadLayer function

s2 = loadLayer("Shape", shpFile=xfile, CRS="EPSG:25830")

(31)

Capas Raster

Para cargar capas raster usaremos la función loadRasterFile(). Esta es una función de apoyo que llama a la función createLayer() más genérica.

Si necesitamos transformar una ruta a formato uri podemos hacerlo apoyándonos en la clase de Java:

java.io.File:

Ejemplo:

from gvsig import * from java.io import File def main(*args):

# Load Raster File

raster_path = os.path.join(os.path.dirname(__file__),"data","mdt_jaen.tif") r1 = loadRasterFile(raster_path)

raster_uri = File(os.path.join(os.path.dirname(__file__),"data","fichero.xx")).toURI() r2 = loadLayer("Gdal Store", uri=raster_uri)

Ficheros DBF

Para trabajar con la creación y carga de ficheros DBF existen las funciones createDBF(schema) y loadDBF(dbfFile). Siendo un objectoDefaultFeatureStore

Ejemplo de uso:

schema = createSchema()

schema.append("ID", "INTEGER")

dbf = createDBF(schema, prefixname="summary") print dbf, type(dbf)

path = dbf.getFullName() loadDBF(path)

1.1.6 Otras fuentes de datos

En este apartado se incluirán diferentes funciones interesantes para trabajar con diferentes fuentes de datos. Como caso general vamos a introducir la función openStore(servertype, parameters) para la carga de fuentes de datos desde una ruta o enlace.

Si estos servicios ya se encuentran abiertos en nuestra Vista, podemos acceder a su contenedor de datos seleccionando la capa y accediendo a ella, por ejemplo, mediante un currentLayer().

PostgreSQL

Desde Scripting podemos abrir conexiones a fuentes de datos de tipo PostgreSQL por ejemplo. La función a utilizar será openStore(servertype, parameters).

(32)

El ejemplo está realizado con una base de datos PostGIS creada en local en una máquina Ubuntu siguiendo los siguientes pasos (puede variar según versiones o distribuciones):

sudo apt-get install postgresql postgresql-contrib sudo apt-get install postgresql-9.5-postgis-2.2 sudo apt-get install pgadmin3

$ sudo su - postgres

$ psql

postgres=# select "version"();

#Establecer contraseña entrando en psql postgres=# \password

user: postgres pass: postgres

# Create new db and table

$ dropdb -U postgres ej1

$ createdb -U postgres ej1

$ psql -U postgres ej1 psql (9.5.4)

Digite «help» para obtener ayuda.

ej1=# create extension postgis;

CREATE EXTENSION

ej1=# create extension postgis_topology;

CREATE EXTENSION

ej1=# select postgis_full_version();

ej1=# select srtext from spatial_ref_sys where srid=23030;

ej1=# create table ciudades (gid serial PRIMARY KEY, nombre varchar, poblacion integer);

CREATE TABLE

ej1=# alter table ciudades add column geom geometry (PointZ, 23030);

ALTER TABLE ej1=# \d ciudades

Tabla «public.ciudades»

Columna | Tipo | Modificadores

---+---+--- gid | integer | not null valor por omisión nextval('ciudades_gid_seq'::regclass) nombre | character varying |

poblacion | integer |

geom | geometry(PointZ,23030) | Índices:

"ciudades_pkey" PRIMARY KEY, btree (gid)

ej1=# insert into ciudades (nombre, poblacion, geom) values ('Ciudad A', 10000, st_geomfromtext('POINTZ(700000 45000000 10)', 23030));

INSERT 0 1

ej1=# insert into ciudades (nombre, poblacion, geom) values ('Ciudad B',50000, st_geomfromtext('POINT(720000 4470000 15)',23030));

INSERT 0 1

ej1=# select * from ciudadeS;

gid | nombre | poblacion | geom

---+---+---+--- 1 | Ciudad A | 10000 | 01010000A0F659000000000000C05C2541000000002A7585410000000000002440 2 | Ciudad B | 50000 | 01010000A0F65900000000000000F92541000000003C0D51410000000000002E40 En el siguiente ejemplo vemos como introducimos todos los parámetros necesarios para una conexión PostgreSQL:

(33)

from gvsig.utils import openStore def main(*args):

os = openStore('PostgreSQL',port='5432',

JDBCDriverClass='org.postgresql.Driver', UseSSL='false',

Schema='public', Catalog='',

URL='jdbc:postgresql://localhost/ej1', BaseOrder='',

Workingarea=None, CRS='EPSG:23030', PKFields='gid', BaseFilter='',

DefaultGeometryField='geom', Fields=None,

Table='ciudades', SQL='',

password='postgres', dbname='ej1',

host='localhost', dbuser='postgres',

ProviderName='PostgreSQL')

Una vez tenemos la conexión hecha, podemos comprobar que el tipo de objeto con el que estamos tratando es un DefaultFeatureStore, y por tanto, podemos trabajar de la misma forma que lo haríamos si fuera una capa vectorial, ya que el objeto es del mismo tipo:

print "** os: ", type(os) features = os.features() for f in features:

print f.getValues()

Produciendo por consola una salida similar a:

** os: <type 'org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore'>

{u'gid': 5, u'geom': POINT Z (720000.0 4600000.0 50.0), u'nombre': u'Ciudad A', u'poblacion': 30000}

Geojson

Para cargar un fichero Geojson haciendo uso de la extensión de GDAL:

# encoding: utf-8

os = openStore('OGRDataStoreProvider',file="/home/osc/gvsig-devel/example-data/countries.geojson", CRS="EPSG:4326",

connectionString=None, layerName="OGRGeoJSON",

(34)

defaultGeometryField=None, ignoreSpatialFilter=True,

ProviderName="OGRDataStoreProvider"

) print "geojson: ", type(os)

features = os.features() for feature in features:

print feature

Fichero LIDAR: Las

Cargando ficheros LAS con el driver de Whitebox:

# encoding: utf-8

os = openStore('WhiteboxLASDataStoreProvider', file="/home/osc/LiDAR_6429129715959308627.las", thinningResolution=None,

CRS="EPSG:25830", thinningDivisor=None,

ProviderName="WhiteboxLASDataStoreProvider") print os

features = os.features()

print "Las size: ", features.getSize()

Raster

Cargando ficheros tif:

# encoding: utf-8

os = openStore('Gdal Store',alphaband0None=None, visible=None,

crs="EPSG:4326",

uri="file:/home/osc/Descargas/wc2.0_5m_srad/wc2.0_5m_srad_12.tif", rmf_folder="/home/osc/Descargas/wc2.0_5m_srad",

frame=None, selected_option=0 )

print "raster type: ", type(os)

(35)

1.1.7 Acceso a objectos en gvSIG

Funciones current

Son aquellas funciones que nos ayudan a acceder de una forma rápida a partes de gvSIG que estén en ejecución o cargadas en ese momento. Tales pueden ser como la Vista que tenemos abierta o la capa que tenemos selecciona en esa Vista.

Estas funciones se encuentran dentro de la librería gvsig y son:

currentProject()

Devuelve el proyecto actual de gvSIG currentDocument()

Devuelve el documento actual (Vista o Tabla) currentView()

Devuelve la Vista activa o None. Si no hay Vista activa devuelve un error de RuntimeException currentLayer()

Devuelve la capa activa en la Vista

Por ejemplo, teniendo un Proyecto con una Vista abierta y una capa cargada y seleccionada en esta Vista, ejecutando:

project = gvsig.currentProject() print "project: ", type(project) print "project.name: ", project.name

view = gvsig.currentView() print "view: ", type(view) print "view.name: ", view.name

layer = gvsig.currentLayer() print "layer: ", type(layer) print "layer.name: ", layer.name

Dando como resultado en la consola algo similar a:

Running script acceso.

project: <type 'org.gvsig.app.project.DefaultProject'>

project.name: Sin título

view: <type 'org.gvsig.app.project.documents.view.DefaultViewDocument'>

view.name: Sin título

layer: <type 'org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect'>

layer.name: points_layer-57ab8d7e99c Script acceso terminated.

Proyecto

La clase Project (DefaultProject) se encarga de la gestión de los documentos que tengamos en gvSIG. Este se encarga de las Vistas, Tablas, Mapas, Gráficas y otros que pueden venir desde otras extensiones como el de Series de mapas.

Para acceder a esta clase podemos usarcurrentProject(), nos devolverá la instancia del proyecto que se encuentra actualmente abierto en gvSIG.

(36)

Por ejemplo, podemos obtener su nombre y la proyección establecida en el proyecto:

project = currentProject() name = project.getName()

prjcode = project.getProjectionCode() prj = project.getProjection()

print "Project Name: ", name

print "Projection Code: ", prjcode, type(prjcode) print "Projection: ", prj, type(prj)

Muestra por consola:

Project Name: Sin título

Projection Code: EPSG:4326 <type 'unicode'>

Projection: EPSG:4326 <type 'org.gvsig.crs.Crs'>

En este caso, getProjection() es un método implementado en la API de gvSIG, y getProjectionCode() es un método inyectado en la API de gvSIG desde las librerías de Jython desarrolladas.

Documento Vista

El documento Vista (DefaultViewDocument) contendrá las capas de nuestro proyecto, en el podremos visualizarlas y editarlas.

Para acceder a las Vistas creadas en un Proyecto, podremos usar dos funciones: currentView() o currentDocument() para acceder a la Vista activa, o currentProject().getView(“Nombre”) para acceder a una determinada Vista:

# encoding: utf-8

project = currentProject()

# Acceso a vista con nombre "Vista1"

view1 = currentProject().getView("Vista1")

Una Vista pueden contener diferentes capas o servicios cargados. Un Proyecto puede contener varias vistas. Por ejemplo, con el siguiente script listaremos todas las Vistas que se encuentren en nuestro proyecto:

project = currentProject() views = project().getViews() for view in views:

print view

También podemos realizar otras operaciones. Por ejemplo, podemos crear una Vista nueva en nuestro Proyecto y cambiarle la proyección que tiene:

(37)

project = currentProject()

# Creamos nueva vista

view = project.createView("Nueva Vista") print "Vista nueva: ", view.getName()

print "Proyeccion de la Vista: ", view.getProjectionCode()

# Nos ayudamos de una funcion para obtener el crs object

# correspondiente a un codigo crs newcrs = getCRS("EPSG:32630") view.setProjection(newcrs)

print "Nueva proyeccion de la Vista: ", view.getProjectionCode()

En el caso de que ya exista una Vista con ese nombre, se añadirá a él un indice. Si volvemos a ejecutar el script anterior, el nombre de la nueva vista será: “Nueva Vista - 1”.

Si tenemos la Vista anteriormente creada abierta en gvSIG, podemos acceder directamente a esa Vista abierta cuando ejecutamos nuestro script mediantecurrentView(). Por ejemplo:

view = currentView()

print "Nombre de la Vista: ", view.getName()

Podemos centrar la vista en el punto que queramos:

from gvsig import * from gvsig.geom import *

view = currentView()

encuadre = createEnvelope([10,10],[20,20])

view.getMapContext().getViewPort().setEnvelope(encuadre) view.centerView(createEnvelope([20,20],[50,50]))

Documento Tabla

Otro tipo de documentos que tenemos en nuestro proyecto son las Tablas (DefaultFeatureStore). Estas tablas pueden hacer referencia tanto a tablas añadidas a gvSIG como a tablas de atributos de las capas u otras que aparezcan en este gestor.

De la misma forma que los documentos vista, podemos utilizar la función currentTable() o currentDocument()o project.getTable(“Name”).

Capas

Cualquier capa o servicio añadido a nuestras Vistas serán accesibles mediante Scripting.

(38)

Por ejemplo, una operación básica en herramientas que creemos, sería la creación de una capa vectorial y añadirla a una Vista nueva:

# Creamos esquema para la capa ft = createFeatureType()

ft.append("GEOMETRY", "GEOMETRY")

# Establecemos el tipo del geometria.

# Usamos constantes POINT y D2 que se encuentran

# dentro de la libreria gvsig.geom

ft.get("GEOMETRY").setGeometryType(POINT, D2)

# Creamos la capa nueva con el nuevo esquema

# La funcion se encarga de establecer un path temporal shp = createShape(ft)

# Agregamos la capa a nuesta vista nueva

# Se creara con el nombre de View 001 por defecto newview = currentProject().createView()

newview.addLayer(shp)

Tenemos la opción de iterar sobre todas las capas que tenga una Vista:

view = currentView() layers = view.getLayers()

# Acceder iterando las capas print "\nIterando: "

for layer in layers:

print "\tCapa: ", layer.getName(),

print " Tipo: ", layer.getTypeVectorLayer().getFullName()

# Acceder mediante indices print "\nMediante indices: "

for i in range(0, len(layers)):

print "\tCapa: ", layers[i].getName(),

print " Tipo: ", layers[i].getTypeVectorLayer().getFullName()

Si tenemos una Vista con tres capas, el resultado por consola será similar al siguiente:

Iterando:

Capa: tmpshp-57ae45dd1765 Tipo: Point:2D Capa: tmpshp-57ae45f712b6 Tipo: MultiCurve:2D Capa: tmpshp-57ae45fe1112 Tipo: MultiSurface:3DM Mediante indices:

Capa: tmpshp-57ae45dd1765 Tipo: Point:2D Capa: tmpshp-57ae45f712b6 Tipo: MultiCurve:2D Capa: tmpshp-57ae45fe1112 Tipo: MultiSurface:3DM

Si quieres acceder a capas ya existentes en la Vista podrías hacerlo mediante

(39)

currentView().getLayer("Nombre"), si la tenemos seleccionada en la tabla de contenidos (TOC) mediantecurrentLayer()

Otros métodos que podemos usar sobre una capa añadida son los de .setVisible(True) para modificar su visibilidad en la Vista, o ‘‘ layer.setActive(True)‘‘ para modificar su selección dentro de la Tabla de Contenidos.

Grupo de entidades: FeatureSet

Para obtener las entidades de una capa o tabla, podemos hacer una petición mediante layer.features(), la cual hace una petición al store de la capa, y nos devuelve un featureSet (DefaultFeatureSet) con el filtrado o orden que le asignemos. Este featureSet nos permite iterar sobre las entidades de la capa.

Después, por ejemplo, podemos acceder a estas entidades y a sus valores mediante el método getValues() sobre cada feature, el cual devuelve un diccionario que podemos imprimir:

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

print "Numero entidades: ", features.getSize()

for feature in features:

print feature.getValues() Por consola el resultado en este caso sería:

Numero entidades: 7

{u'NAME': u'Feature1', u'ID': 1L, u'GEOMETRY': POINT (1.0 2.0)}

Podemos hacer diferentes filtrados que devolverían diferentes featureSet. El parámetro expresion pide un String que haga de filtro, el parámetro sortBy el campo sobre el que se ordenará el featureSet, el parámetro asc ordenará en orden ascendente o descendente según el campo seleccionado.

Unos ejemplos de filtrados y sus resultados:

features = layer.features(expresion="ID < 4", sortby="NAME", asc=True) {u'NAME': u'Feature1', u'ID': 1L, u'GEOMETRY': POINT (1.0 2.0)}

features = layer.features(expresion="ID < 4 AND 1 < ID", sortby="NAME", asc=False) {u'NAME': u'Feature2', u'ID': 2L, u'GEOMETRY': POINT (5.0 3.0)}

features = layer.features(expresion="ID < 4 AND NAME != 'Feature1'", asc=True) {u'NAME': u'Feature2', u'ID': 2L, u'GEOMETRY': POINT (5.0 3.0)}

(40)

Otras opciones más avanzadas usando la API de gvSIG:

layer = currentLayer() #layer_append_features.main() features = layer.features()

print "\n Show features: "

for f in features:

print f

fquery = layer.getDataStore().createFeatureQuery() fquery.addAttributeName("ID")

fquery.addAttributeName("GEOMETRY")

#FeatureQuery print "\nFQuery"

#fquery.setLimit(3)

fset = layer.getDataStore().getFeatureSet(fquery) for i in fset:

print i

#FeatureQueryOrder

print "\n Fquery order geometry"

forder = layer.getDataStore().createFeatureQuery().getOrder() print forder

forder.add("GEOMETRY", True) fquery.setOrder(forder)

fsetorder = layer.getDataStore().getFeatureSet(fquery) for i in fsetorder:

print i

Entidad

Antes hemos visto que podemos acceder a los valores de cada entidad (DefaultFeature) con getValues(), pero también podemos acceder directamente mediante feature.FIELD o feature.get(“Field”). Por ejemplo:

layer = currentLayer() features = layer.features() for feature in features:

print "ID: ", feature.ID, " NAME: ", feature.get("NAME")

La salida por consola será:

ID: 1 NAME: Feature1 ID: 2 NAME: Feature2 ID: 3 NAME: Feature2 ID: 4 NAME: Feature2 ID: 5 NAME: Feature3

(41)

ID: 6 NAME: Feature3 ID: 7 NAME: Feature3

Selección

Otro tipo de featureSet es elDefaultFeatureSelection. Hace referencia a los objetos que tengamos seleccionados en la capa.

Un ejemplo de su uso, teniendo 3 entidades seleccionadas:

layer = currentLayer()

#features = layer.features() selection = layer.getSelection() for feature in selection:

print "ID: ", feature.ID, " NAME: ", feature.get("NAME")

Dando como resultado:

ID: 1 NAME: Feature1 ID: 2 NAME: Feature2 ID: 3 NAME: Feature2

Disponemos de dos métodos especiales para esta clase como son el .selectAll() para seleccionar todas las entidades de esa capa o .deselectAll() para deseleccionar todos ellos.

Por ejemplo, añadiremos a la selección ciertas entidades que cumplan un criterio:

#Entidades de la capa features = layer.features()

#Seleccion de entidades

selection = layer.getSelection() selection.deselectAll()

for feature in features:

if feature.ID < 3:

# Agregamos entidades a la seleccion selection.select(feature)

Si quisiéramos eliminar entidades de la selección, podríamos usar el método .deselect(feature) Por otra parte, también podríamos crear una selección o varias desde Scripting:

(42)

# Create a new selection layer = currentLayer() features = layer.features()

newselection = layer.getDataStore().createSelection() for f in features:

if f.ID!=10:

newselection.select(f)

layer.getDataStore().setSelection(newselection)

1.1.8 Trabajando con esquemas: FeatureType

Los descriptores contienen la información sobre el nombre, tipo, precisión, etc de los campos en nuestros contenedores de datos.

Según sea su uso tendrán que cumplir ciertos requisitos. Por ejemplo, si creamos una capa vectorial, su esquema tiene que tener obligatoriamente un campo GEOMETRY establecido.

Creando esquemas

createFeatureType([schema=None]):

Create an empty schema. If parameter schema is aDefaultEditableFeatureType, creates a copy of this schema DefaultFeatureType.

Parámetros schema (DefaultEditableFeatureType) – Schema from other layer Devuelve empty schema or a copy of a schema

La interfazDataTypesespecifica un conjunto de constantes indicando los tipos de datos soportados por DAL.

Vamos a ver como crear un esquema con dos campos y asignarle este esquema a una nueva tabla:

schema = createFeatureType() # DefaultFeatureType schema.append("ID", "INTEGER", 10)

schema.append("NAME", "STRING", 20) dbf = createDBF(schema)

d = loadDBF( dbf.getFullName()) # Carga tabla en el proyecto

También podemos crear un esquema nuevo basado en otro ya existente, muy útil para cuando queramos hacer copias de capas. Para pasar un esquema para la creación de capas debe ser de tipo DefaultFeatureType, la función :py:func:createFeatureType() convierte el esquema de tipoDefaultEditableFeatureTypeen el necesario:

schema = createFeatureType() # DefaultFeatureType

(43)

schema.append("ID", "INTEGER", 10) schema.append("NAME", "STRING", 20) dbf_1 = createDBF(schema)

dbf_schema = dbf_1.getSchema() # DefaultEditableFeatureType

# Nuevo esquema basado en el de otra capa new_schema = createSchema(dbf_schema) new_schema.append("CODE", "STRING", 5) dbf_2 = createDBF(new_schema)

Una forma de acceder a los descriptores contenidos en el esquema es mediante schema.get("Campo"). También podemos iterar sobre ellos. En el siguiente ejemplo, vemos la forma de añadir diferentes campos de diferentes tipos a un esquema nuevo. Hemos preparado una función que itera sobre ellos para mostrar una información completa sobre el esquema que le pasemos como parámetro, quedando:

def showInfoFeatureType(schema):

#Show schema

attrSchema = schema.getAttrNames() print "Schema attr: ", attrSchema

#First field in schema field1 = schema.get(0)

# Description of the fields print "\nFields description"

for field in schema:

print " Name: ", field.getName(),

print " \tDataTypeName: ", field.getDataTypeName(), print " \tType: ", field.getType(),

print " \tSubType: ", field.getSubtype(), print " \tPrecision: ", field.getPrecision(), print " \tSize: ", field.getSize()

if field.getDataTypeName() == 'Geometry':

geomType = field.getGeomType()

print " \tGeom Name: ", geomType.getName()

print " \tGeom FullName: ", geomType.getFullName() print " \tType: ", geomType.getType()

print " \tSubType: ", geomType.getSubType()

print " \tGeometryClass: ", geomType.getGeometryClass() print " \tDimension: ", geomType.getDimension()

schema = createFeatureType() schema.append("ID", "INTEGER", 10) schema.append("NAME", "STRING", 20) schema.append("AREA", "DOUBLE", 20, 10) schema.append("FECHA", "DATE", 20) schema.append("ACTIVE", "BOOLEAN") schema.append("GEOMETRY", "GEOMETRY")

schema.get('GEOMETRY').setGeometryType(POINT, D2)

(44)

shape = createShape(schema, prefixname="date") currentView().addLayer(shape)

showInfoFeatureType(schema) Por consola se muestra:

Schema attr: [u'ID', u'NAME', u'AREA', u'FECHA', u'ACTIVE', u'GEOMETRY']

Fields description

Name: ID DataTypeName: Integer Type: 4 SubType: None Precision: 0 Size: 10 Name: NAME DataTypeName: String Type: 8 SubType: None Precision: 0 Size: 20

Name: AREA DataTypeName: Double Type: 7 SubType: None Precision: 4 Size: 20 Name: FECHA DataTypeName: Date Type: 9 SubType: Date Precision: 0 Size: 20

Name: ACTIVE DataTypeName: Boolean Type: 1 SubType: None Precision: 0 Size: 0

Name: GEOMETRY DataTypeName: Geometry Type: 66 SubType: Geometry Precision: 0 Size: 0 Geom Name: Point2D

Geom FullName: Point:2D Type: 1

SubType: 0

GeometryClass: <type 'org.gvsig.fmap.geom.jts.primitive.point.Point2D'>

Dimension: 2

Modificando esquemas

En el siguiente ejemplo, vamos a modificar un esquema:

schema.append("NAME", "STRING", 20) schema.append("CODE", "STRING", 2)

# By index schema.remove(0)

print "Remove descriptor ID: ", schema.getAttrNames()

# By descriptor

rm = schema.getEditableAttributeDescriptor("CODE") schema.remove(rm)

print "Remove descriptor CODE: ", schema.getAttrNames()

# Add geometry field

schema.append("GEOMETRY", "GEOMETRY")

schema.get("GEOMETRY").setGeometryType(POINT, D2) print "Add geometry field: ", schema.getAttrNames()

Muestra por consola lo siguiente:

Remove descriptor ID: [u'NAME', u'CODE']

Remove descriptor CODE: [u'NAME']

Add geometry field: [u'NAME', u'GEOMETRY']

(45)

Esquema para capas vectoriales

Para la creación de una capa vectorial sería un ejemplo muy similar, solamente debería de contener un campo GEOMETRY de tipo GEOMETRY. Después de crear este campo, tenemos que establecer el tipo de geometría que contendrá.

En este ejemplo mostramos el caso típico de creación de una capa vectorial nueva:

schema.append("NAME", "STRING", 20) schema.append("GEOMETRY", "GEOMETRY")

schema.get("GEOMETRY").setGeometryType(POINT, D2) shape = createShape(schema)

currentView().addLayer(shape)

1.1.9 Trabajando con capas: FLayer

Trabajando con capasFLayer

createShape(definition

[

, filename=None, geometryType=None, CRS=None, prefixname=”tmpshp”

]

)

Creates a new shape layer. If geometryType is None, will take geometry type from the definition. If parameter geometryType and the geometry type inside the definition are different, raises an error.

Parámetros

definition– Layer schema :type definition: DefaultFeatureType filename(str) – Full path

geometryType–

type geometryType GeometryType

CRS(str) – CRS Code :param str prefixname: first part of the temp name

La interfaz FLayer viene implementada en varias capas de uso común como son las capas vectoriales o raster.

Capas vectoriales: FLyrVect

Unas de las operaciones más importantes es el trabajo con capas vectorialesFLyrVect. Hemos querido simplificar al máximo posible el trabajo con ellas, sobretodo si eres un nuevo desarrollador.

Ya hemos visto anteriormente la generación de esquemas que pueden ser usados en capas vectoriales. La única condi- ción de estos esquemas es que contengan un campo GEOMETRY con un tipo de geometría establecido.

Crear capa vectorial

Para la generación de capas hemos simplificado al máximo la función :py:func:createShape(definition). El único parámetro obligatorio será el esquema de la capa con su campo geometría.

(46)

Por ejemplo, lo mínimo necesario para crear una capa es:

schema = createFeatureType() # DefaultFeatureType schema.append("GEOMETRY", "GEOMETRY")

schema.get("GEOMETRY").setGeometryType(POINT, D2) shape = createShape(schema)

De esta forma, si la ruta o el nombre del fichero no es importante para nosotros, algo muy común a la hora de generar capas para resultados de geoprocesos o similares, la función se encargará de asignarle una ruta en una carpeta temporal y un nombre aleatorio (basado en códigos de tiempo).

Otra forma sería usar directamente la funcion createLayer():

layer = createLayer(schema=schema,

servertype="FilesystemExplorer", layertype="Shape",

shpFile="/home/osc/temp/test1.shp", CRS="EPSG:25830",

geometryType=geom.POINT )

Así en el script anterior podemos añadir las líneas:

print "Nombre: ", shape.getName()

print "Ruta: ", shape.getDataStore().getFullName()

Que darán como resultado el nombre y ruta de la capa, similar a:

Nombre: tmpshp-57afa1381035

Ruta: C:\Users\Oscar\AppData\Local\Temp\tmp-andami\tmpshp-57afa1381035.shp

Si necesitas crear varias capas y necesitas poder diferenciarlas, por ejemplo, al enlazar una serie de operaciones, podemos establecer el parámetro prefixname el cual modificará la primera parte del nombre, pero seguirá creando todo el resto de ruta temporal y asegurándonos que será un nombre único:

schema = createFeatureType() # DefaultFeatureType schema.append("GEOMETRY", "GEOMETRY")

schema.get("GEOMETRY").setGeometryType(POINT, D2) shape1 = createShape(schema, prefixname="resultado") shape2 = createShape(schema, prefixname="errores") shape3 = createShape(schema, prefixname="puntos")

print "Nombre: ", shape1.getName(), "\tRuta: ", shape1.getDataStore().getFullName() print "Nombre: ", shape2.getName(), "\tRuta: ", shape2.getDataStore().getFullName() print "Nombre: ", shape3.getName(), "\tRuta: ", shape3.getDataStore().getFullName()

Por consola muestra el nombre de las capas como indicábamos:

(47)

Nombre: resultado-57afa4f612c9 Ruta: C:\Users\Oscar\AppData\Local\Temp\tmp-andami\resultado-57afa4f612c9.shp Nombre: errores-57afa4f613a6 Ruta: C:\Users\Oscar\AppData\Local\Temp\tmp-andami\errores-57afa4f613a6.shp

Nombre: puntos-57afa4f61446 Ruta: C:\Users\Oscar\AppData\Local\Temp\tmp-andami\puntos-57afa4f61446.shp

Modificar esquema de una capa

El siguiente script modificará el esquema de una capa. Para ello tenemos que crear un esquema nuevo basado en el anterior de la capa mediante createFeatureType(layer_schema), realizar las modificaciones y actualizar la capa:

from gvsig import * from gvsig import geom def main(*args):

"""Updating schema of existent layer"""

layer = currentLayer() schema = layer.getSchema() newschema = createSchema(schema) newschema.append("ID2", "STRING") layer.edit()

layer.update(newschema) layer.commit()

Operaciones con entidades

Una vez creada la capa nueva o accedido a una de ellas con currentLayer() o view.getLayer("Name"), podemos acceder a sus entidades mediante el método .features(), tal y como explicamos en la guía de Acceso a datos.

Lo siguiente que haremos es añadir datos a esta capa vectorial. Para ello ponemos la capa en modo de edición mediante layer.edit()y agregamos las entidades con layer.append(args):

schema.append("NAME", "STRING", 10) schema.append("GEOMETRY", "GEOMETRY")

schema.get("GEOMETRY").setGeometryType(POINT, D2) shape = createShape(schema, prefixname="resultado")

print "Nombre: ", shape.getName(), "\tRuta: ", shape.getDataStore().getFullName()

shape.edit()

# Setting arguments

shape.append(ID=1, NAME="Valencia", GEOMETRY=createPoint2D(10, 10))

(48)

# Diccionary

shape.append({"ID": 2, "NAME": "Paris", "GEOMETRY":createPoint2D(15, 15)}) shape.commit()

currentView().addLayer(shape)

Otro ejemplo añadiendo entidades, usando también la forma con la que se haría desde Java:

import gvsig reload(gvsig) from gvsig import * from gvsig import geom

from org.gvsig.fmap.dal.feature import FeatureStore def main(*args):

# Creating new layer schema = createSchema()

schema.append("ID", "INTEGER") schema.append("NAME", "STRING", 10) schema.append("GEOMETRY", "GEOMETRY")

schema.get('GEOMETRY').setGeometryType(geom.POINT,geom.D2) layer = createShape(schema, prefixname="points_layer")

# Insert with newfeature

store = layer.getFeatureStore() newfeature = store.createNewFeature() newfeature.set("ID",1)

newfeature.set("NAME","Feature1")

newfeature.set("GEOMETRY", geom.createPoint(geom.D2, 1,2))

layer.edit(FeatureStore.MODE_APPEND) #solo para capas recien creadas store.insert(newfeature)

layer.commit()

# Insert with append layer.edit()

layer.append(ID=2,NAME='Feature2',GEOMETRY=geom.createPoint(geom.D2, 5, 3))

layer.append({'ID':3,'NAME':'Feature2','GEOMETRY':geom.createPoint(geom.D2, 3, 3)}) layer.append({'ID':4,'NAME':'Feature2','GEOMETRY':geom.createPoint(geom.D2, 2, 1)}) layer.append({'ID':5,'NAME':'Feature3','GEOMETRY':geom.createPoint(geom.D2, 2, 6)}) layer.append({'ID':6,'NAME':'Feature3','GEOMETRY':geom.createPoint(geom.D2, 6, 2)}) layer.append({'ID':7,'NAME':'Feature3','GEOMETRY':geom.createPoint(geom.D2, 2, 7)}) layer.commit()

# Add layer to the view currentView().addLayer(layer) print "Features info"

for l in layer.features():

print l

Si al final del script anterior añadimos las siguientes líneas, veremos un ejemplo para eliminar entidades:

features = layer.features("ID < 6") #DefaultFeatureSet

(49)

layer.edit() print type(layer)

print features, type(features) for i in features:

features.delete(i) layer.commit()

Para modificar los valores de las entidades que contiene nuestra capa:

layer.edit() for i in features:

print i

c = i.getEditable()

c.set("NAME", "Modified_4") features.update(c)

layer.commit()

Se puede realizar copias de entidades (features) y poder modificarlas después en su capa original.

Ejemplo: Extraemos ciertas entidades de una capa que contiene un Campo1 de tipo Long. Estas entidades las copiamos a una lista. Después, modificamos estas entidades y las volvemos a modificar sobre la capa inicial:

features = layer.features('Campo1>2',sortBy="Campo1",asc=True) lista = []

for f in features:

print f

copia = f.getCopy() print type(copia) lista.append(copia) print len(lista)

layer.edit() for i in lista:

value = i.get('Campo1')+0.01 i = i.getEditable()

i.set('Campo1', value)

print "new value", i.get('Campo1'), type(i) featureSet = layer.features()

layer.features().update(i) layer.commit()

1.1.10 Módulo de geometrías: geom

Una geometría es un objeto que contiene información geométrica. Estas geometrías tienen un tipo principal: Point, Line, Polygon.. y un subtipo o dimensión: D2, D3, D2M..

Para el Módulo de Scripting hemos creado la librería gvsig.geom que nos ayudará para crear rápidamente las geome- trías que necesitemos. Para algunas operaciones más complicadas tendremos que usar la API de gvSIG.

Para establecer estos tipos y subtipos lo haremos utilizando las constantes que se incluyen en la librería.

Constantes que aparecen en la librería gvsig.geom para la creación de geometrías:

(50)

#GeometryTypes

AGGREGATE = Geometry.TYPES.AGGREGATE ARC = Geometry.TYPES.ARC

CIRCLE = Geometry.TYPES.CIRCLE CURVE = Geometry.TYPES.CURVE ELLIPSE = Geometry.TYPES.ELLIPSE

ELLIPTICARC = Geometry.TYPES.ELLIPTICARC GEOMETRY = Geometry.TYPES.GEOMETRY MULTICURVE = Geometry.TYPES.MULTICURVE MULTIPOINT = Geometry.TYPES.MULTIPOINT MULTISOLID = Geometry.TYPES.MULTISOLID MULTISURFACE = Geometry.TYPES.MULTISURFACE NULL = Geometry.TYPES.NULL

POINT = Geometry.TYPES.POINT SOLID = Geometry.TYPES.SOLID SPLINE = Geometry.TYPES.SPLINE SURFACE = Geometry.TYPES.SURFACE

# Common named geometry types POLYGON = Geometry.TYPES.SURFACE LINE = Geometry.TYPES.CURVE

MULTILINE = Geometry.TYPES.MULTICURVE MULTIPOLYGON = Geometry.TYPES.MULTISURFACE

# geometrySubTypes

D2 = Geometry.SUBTYPES.GEOM2D D2M = Geometry.SUBTYPES.GEOM2DM D3 = Geometry.SUBTYPES.GEOM3D D3M = Geometry.SUBTYPES.GEOM3DM UNKNOWN = Geometry.SUBTYPES.UNKNOWN

# Dimensions

DIMENSIONS = Geometry.DIMENSIONS Ejemplo testeando la librería de geom:

import gvsig reload(gvsig) from gvsig import * from gvsig import geom

# Create Polygon

print "\nCreate Polygon"

x = geom.createPolygon()

pol_1 = geom.createPolygon(vertexes=[geom.createPoint(geom.D2, 4,5),geom.createPoint(geom.D2,3,3),geom.createPoint(geom.D2,3,2),geom.createPoint(geom.D2,4,5)]) print "pol_1: ", pol_1.convertToWKT()

pol_2 = geom.createPolygon(vertexes=[geom.createPoint(geom.D2,4,5),geom.createPoint(geom.D2,3,3),geom.createPoint(geom.D2,3,2),geom.createPoint(geom.D2,4,5)]) print "pol_2: ", pol_2.convertToWKT()

pol_3 = geom.createPolygon(vertexes=[geom.createPoint(geom.D2,4,5),geom.createPoint(geom.D2,3,3),geom.createPoint(geom.D2,3,2),geom.createPoint(geom.D2,4,5)]) print "pol_3: ", pol_3.convertToWKT()

pol_4 = geom.createPolygon(geom.D2,[(0,0),(10,10),[3,3],[3,6],[0,0]]) print "pol_4: ", pol_4.convertToWKT()

# Create MultiPolygon