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:
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):
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
import psycopg2
# 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.
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
Campos
Disculpe este sitio se encuentra en construcción!!!
{mospagebreak}
cript de inicio del plugin QGIS
