You are here:GeoTux»Geo-Blogs»Desktop GIS»Desarrollo de Plugins QGIS con Python

Statistics

Invitados: 20
Usuarios registrados: 2548
Usuarios en línea:
-
Registrados hoy:
-

Register

RSS

Blogs and News:
Recibe las actualizaciones en Geo-Noticias y Geo-Blogs

Get them by e-mail
Recibir Geo-Noticias y Geo-Blogs por e-mail

¿What is this about?

Wednesday, 31 October 2007 02:43

Desarrollo de Plugins QGIS con Python

Written by  Samuel Fernando Mesa Giraldo
Rate this item
(0 votes)

Me encontré con la grata sorpresa que a partir de la versión 0.9 de QGIS trae soporte del lenguaje Python que junto con el módulo PyQT4 entrega una solución al desarrollo de plugins e interfaces gráficas de usuario SIG. Python se caracteriza por una elegante sintaxis que lo constituye como un lenguaje interpretado de alto nivel, multiplataforma y modular lo que permite el desarrollo de aplicaciones de forma rápida y sencilla. Por su gran rango de funcionalidades es seleccionado como el lenguaje de scripts ideal que se integra a una gran variedad de herramientas SIG y de procesamiento digital de imágenes como es el caso de SAGA GIS, GDAL/OGR, OpenEV, Thuban, GRASS GIS, GMT, Mapserver .... ahhhh y el software propietario de ArcGIS.

Adicionalmente a las interfaces que puedan construirsen en QT, también pueden encontrarse soluciones como Wxwidgets, Tk, GTK y entre otras módulos de software orientados aplicaciones de escritorio o interfaces Web.

DESARROLLANDO MI PRIMER PLUGIN DE QGIS CON PYTHON

La presente guía está basado en los documentos de “Shuffling Quantum GIS into the Open Source GIS Stack” de Gary E. Sherman y "Developing QGIS plugins with Python HOWTO" de Quantum GIS Wiki los cuales pueden consultarse en:

http://wiki.qgis.org/qgiswiki/FOSS4G2007_Conference
http://wiki.qgis.org/qgiswiki/DevelopingPluginsWithPython


Antes de empezar

Debe tener en cuenta las siguientes dependencias de software para la construcción de mi primer Plugin de QGIS con Pyhon.

QGIS >=v0.9 (Descargar )
Python >=v2.5 (Descargar )
PyQT GPL >=v4 (Descargar)

psycopg >=>= 2.0.x (Descargar )
PostgreSQL >= 8.x (Descargar )
PostGIS >= 8.x (Descargar )

En esta guía no se especifica la instalación del SMBD PostgreSQL ni la configuración y creación de base de datos con PostGIS, para mayor información ir a la sección PostGIS del Geo-Wiki.

También es recomendable algunas herramientas de desarrollo con Python que permita el resaltado de sintaxis, entre algunos de ellos los entornos de desarrollo ERIC que viene incluido con el instalador de PyQT GPL, Stani's Python Editor (SPE) o el minimalistico Notepad++.

Mi primer plugin

El plugin de QGIS consistirá de una interfaz que permita la creación de nuevas capas geográficas en una base de datos espacial de PostGIS, solicitara al usuario el nombre de la nueva capa de PotsGIS, el nombre de los campos y la cadena de conexión a la base de datos espacial.

1. Crear el directorio del plugin

Al cargar el programa de QGIS se verifica los plugins disponibles ya sea en los lenguajs C++ o Python.

En Python los plugins se organizan en directorio, así que el primer paso es la creación de una carpeta, para nuestro caso llamado “nueva_capa_PostGIS”, donde contendrá todas las fuentes del programa entre otros recursos. La ruta en Windows donde se crea la carpeta es:

C:\ruta_programas\Quantum GIS\python\plugins

La estructura de archivos que contendrá como mínimo este directorio mínima son:

a. __init__ .py
b. nuevo_capa.py
c. resources.py
d. resources.qrc

En Python los guiones o scripts de programación por convención suelen almacenarse en archivos con extension *.py.

 

2. Crear el script de inicio del plugin QGIS

 

El primer script que se construye denominado “__init__.py” es referente a la inicialización con lo cual el programa QGIS reconocerá como plugin, en este se especifica información básica tal como nombre, descripción, versión, entre otra información del plugin. Este script debe contener:

# Leer la clase NuevaCapa desde el guion nueva_capa.py
from nueva_capa import NuevaCapa
def name():
return "Nueva capa PostGIS"
def description():
return "Crea una nueva capa vacia PostGIS"
def version():
return "Version 0.00001"
def classFactory(iface):
return NuevaCapa(iface)

 

Cada función simplemente retorna una cadena de texto con la información acerca del plugin . Un requerimiento es que el método classFactory retorne una referencia al plugin mismo con argumento del objeto iface. La función classFactory() recibe como referencia una instancia de QgisInterface y returna una instancia del plugin, para nuestro caso este es llamdo como NuevaCapa, que es la clase que se especifica  en el script “nueva_capa.py” que se crea en el siguiente paso.

Recuerde que en Python los bloques que define clases, funciones o bucles de control son definidas con una apropiada indentación (tabulaciones), esta es una gran diferencia con respecto a otros lenguajes como C++ y Java en los que es necesario encapsular código a través de corchetes ({}) y en los que se requiere terminar sentencias con punto y coma (;). Adicionalemnte los comentarios son realizados con el carácter “#” y para dividir en más de una línea una sentencia se utiliza el carácter “\”.

3. Crear el script de inicio del plugin

Crear el archivo “nueva_capa.py” en donde se especifica la interfaz de usuario en forma de diálogo que recibirá el nombre de la nueva capa PostGIS, los campos que almacenará y la cadena de conexión a nuestra base de datos. El archivo contendrá las siguientes líneas de código (OJO tenga espacial atención con la indentación del código y con los espacios entre sentencias):

 

# Importar las librerias PyQT y QGIS

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
import psycopg2
# Inicilizar recursos QT desde el archivo resources .py
import resources

# Nuestra clase principal del plugin
class NuevaCapa:

def __init__ ( self , iface ):
# Guardar referencia a la interface QGIS
self.iface = iface

def initGui( self ):
# Configuracion por defecto del plugin
self.action = QAction(QIcon(":/plugins/nueva_capa_PostGIS/icono.png"),\
"Nueva capa PostGIS", self.iface.getMainWindow())
QObject.connect(self.action, SIGNAL("activated()"), self.run)

# Agregar boton al menu y barra de herramientas
self.iface.addToolBarIcon(self.action)
self.iface.addPluginMenu("&Nueva capa PostGIS...", self.action)

def unload(self ):
# Deshabilitar el plugin del menu y barra de herramientas
self.iface.removePluginMenu("&Nueva capa PostGIS...", self.action)
self.iface.removeToolBarIcon(self.action)

def run(self ):
# Entradas del usuario, nombre de tabla
tabla_nombre = QInputDialog.getText(None, "Nombre de tabla?", \
"Nombre para la nueva capa PostGIS")

if tabla_nombre[0].length() > 0:
# Obtener nombre y tipos de los campos
campos = QInputDialog.getText(None, "Nombre de campos", \
"Campos (separados con una coma)")
partes = campos[0].split ( ',' )
# Crear sentencia SQL
sql = "create table "+tabla_nombre[0]+" (id int4 primary key, "
for campos in partes:
sql += campos + " varchar(10), "
sql = sql[0:-2]
sql += ")"
# Conexion a la bases de datos
# Primero obtener DSN
dsn = QInputDialog.getText(None, "DSN de la base de datos", \
"Ingrese DSN para la conexion (dbname=basedatos user=usuario)")
if dsn [0]. length() > 0:
con = psycopg2.connect(str(dsn[0]))
curs = con.cursor()
curs.execute(str( sql ))
con.commit()
# Agregar columna de geometria
curs.execute("select AddGeometryColumn('"+str(tabla_nombre[0])+ \
"', 'the_geom', 3115, 'POLYGON', 2)")
con.commit()
# Crear GIST index
curs.execute("create index sidx_"+str(tabla_nombre[0])+" on " + \
str(tabla_nombre[0]) + " USING GIST(the_geom GIST_GEOMETRY_OPS)")
con.commit()
# Resultado de la creacion de la capa
QMessageBox.information(None, "Resultados", "La tabla " + str(tabla_nombre[0]) + \
" ha sido creada existosamente. Confirme en su base de datos.")
else:
QMessageBox.warning(None,"Error", "Debe ingresar un nombre a la capa")

 

En las primeras líneas se importa los módulos de Python necesarios para el desarrollo de los plugins, este incluye las librerías de PyQT4, QGIS y el módulo de Python con PostgreSQL denominado psycopg. Debe tener en cuenta que al crear interfaces con QGIS y PyQT siempre es necesario importar las librerías PyQt4.QtCore, PyQt4.QtGui y qgis.core.

Posteriormente se declara la clase NuevaCapa en el que se especifica la inicialización a través del método __init__ y el cual se realizada un llamado en la última línea del script “__init__.py”. En esta clase también se define la variable miembro iface que permite referenciar a la interfaz principal de QGIS.

El método initGui() de la clase NuevaCapa inicializa los elementos del plugin, en QT la función QAction() es usado para crear una acción de interfaz de usuario y aquí es usado para crear los items en la barra de menús y herramientas, de esta forma se agrega un icono, texto que aparecerá en los ítems del menú y texto desplegable de ayuda.

 

plugin1

El último parámetro de este función que hace el llamado del objeto iface que en úlltima especifica la interfaz “padre” o ventana principal del programa QGIS. Las últimas líneas de esta función agrega los items correspondientes a las barras de menú y herramientas a la interfaz padre.

El método unload() de la clase NuevaCapa es usado para deshabilitar el plugin una vez que el usuario de esta forma lo defina desde el administrador de extensiones de QGIS.

Tabla

Tabla

 

Campos

Campos
DSN
Aviso
PostGIS
Cargar

 

 

Disculpe este sitio se encuentra en construcción!!!

 

 

 

 


{mospagebreak}

New layer...
New layer...

cript de inicio del plugin QGIS

 

Last modified on Thursday, 29 September 2011 04:09

Add comment


Security code
Refresh

 

On-line users