Personalización de QGIS utilizando Python

1.- Conociendo la consola Python de QGIS

La consola PyQGIS, forma parte del software QGIS, es el entorno para ejecutar código pyqgis.
Descripción del entorno de la consola python en QGIS.

Botones de control
de la consola

Botones de control
de la consola
Área de despliegue Editor de scripts
de resultados PyQGIS

Área de comandos pyQGIS

Botón de Control de consola

Botones de control
de la consola

Limpiar Consola. - limpia el área de despliegue de resultados

Ejecutar comando. - Ejecuta la instrucción (comando) que se tecleo en el área de comandos.

Mostrar Editor. - Muestra el editor de scripts a la derecha de la consola Python

Opciones. - Muestra ventana con las opciones para configurar el ambiente de la consola

Ayuda. - Muestra la ventana de ayuda para la consola Python

 Área de despliegue de resultados de la ejecución de comandos pyqgis de la ejecución de comandos
pyqgis.

Área de despliegue de
resultados

Área de comandos pyqgis donde se teclean los comandos pyqgis a ejecutarse por ejemplo podemos
decir que imprima el resultado de la suma de 2+6:

Editor de scriptsel, cual se compone de una barra de herramientas y de un área de edición de

código.

Activar – Mostrar
Botones de
editor
control de la
consola

Editor de scripts
PyQGIS
Abrir script. – Abre un script guardado para poder editarlo y ejecutarlo.

Abrir en editor externo. – abre el script actual en un editor fuera de la consola de pyqgis.

Guardar. – Almacena el script guardando los últimos cambios.

Guardar como. – Almacena el script actual con un nombre diferente

Ejecutar script. – Ejecuta el script actual.

Cortar. -Corta el fragmento de texto seleccionado del script.

Copia. -Copia el texto seleccionado.

Pegar. – Pega el texto previamente copiado o pegado (el que este en el clipboard).

Buscar Texto. -Localizar un fragmento de texto en script editado.

Comentar. – Pone como comentario las líneas seleccionadas del script.

Descomentar. -Quita el signo de comentario a las líneas seleccionadas.

Inspector de objetos. -Muestra los objetos a manera de árbol para revisar dicho objeto.
2.- Introducción a PyQGIS
¿Qué es PyQGIS?

PyQGIS es la librería de QGIS para ejecutar código Python. A partir de la versión 0.9 en septiembre
de 2007, QGIS tiene soporte para ejecutar scripts utilizando el lenguaje Python.
https://qgis.org/pyqgis/3.4/

¿Qué podemos hacer con PyQGIS?

I.-Podemos automatizar tareas GIS. Listar el número de registros de las capas, realizar
geoprocesamiento, añadir y borrar elementos de una capa o tabla, crear geometrías nuevas, etc.

II.-Crear complementos de QGIS (plugins) utilizando Python como lenguaje de programación. La

principal ventaja de utilizar Python es la simplicidad en la distribución y un desarrollo sencillo.

III.- Ejecutar aplicaciones personalizadas. Con PyQGIS podemos crear aplicaciones interactivas con
funcionalidades GIS. El módulo qgis.gui trae diversos componentes visuales GUI. El widget
mapcanvas puede ser fácilmente incorporado en la aplicación con soporte para zoom, pan y otras
herramientas.

¿Qué ventajas me aporta PyQGIS?

• Podrás generar tus propios scripts para almacenar en ellos los procesos GIS que antes hacías
a mano: ahorras tiempo y ganaras precisión.
• Generarás con facilidad inventarios, informes y consultas sobre los contenidos GIS que
manejas: tendrás registradas y actualizadas tus capas, tablas, datos, etc.
• Pasarás de realizar pequeñas operaciones GIS a gestionar grandes volúmenes de
información.
Antes de comenzar a crear complementos, es importante comprender el marco de Python
subyacente utilizado por QGIS. PyQGIS está organizado en 4 módulos principales:

• qgis.core
• qgis.gui
• qgis.analysis
• qgis.server

qgis.core

Este módulo trata con la funcionalidad de mapeo central y manejo de datos de QGIS. Esto incluye
crear y acceder a capas, generar diseños, agregar etiquetas, simbología, operaciones de tabla
(uniones, creación de campos, etc.).

Piense en este módulo como la representación programática del navegador de datos y la ventana
de capa.
qgis.gui

Este módulo se aplica tanto a los complementos como lo analizamos en este documento, así como
a las aplicaciones independientes que utilizan las bibliotecas QGIS. Vamos a entrar en esos más
tarde.

El módulo GUI incluye widgets gráficos que se pueden usar para crear cajas de herramientas, áreas
de lienzo de mapas y otros elementos gráficos para un complemento o aplicaciones independientes.
Por ejemplo, la clase qgis.gui.QgsMapCanvas () crea un widget de lienzo de mapa que se puede usar
para mostrar datos geoespaciales en un complemento o en una aplicación independiente sin tener
que crear uno nuevo.

qgis.analysis

El módulo de análisis incluye todas las herramientas necesarias para el análisis de datos y espacial.
Estas incluyen herramientas para verificar la topología, crear gráficos, editar etiquetas EXIF de
etiquetas geográficas etiquetadas, etc.

Estas herramientas se utilizan normalmente en trabajos geoespaciales de alto nivel en los que ya se
ha hecho la creación y edición de características y se debe generar inteligencia espacial. Las
interpolaciones ráster también se tratan en este módulo.

qgis.server

Como es de esperar por el nombre, el módulo del servidor está destinado a ser utilizado en un
servidor QGIS. Se utiliza para gestionar los servicios de publicación y las capas, así como para
gestionar el tráfico y las solicitudes de geoprocesamiento realizadas al servidor.

PyQt5
Qt es un conjunto de bibliotecas C ++ multiplataforma que implementan API de alto nivel para
acceder a muchos aspectos de los sistemas modernos de escritorio y móviles. Estos incluyen
servicios de ubicación y posicionamiento, conectividad multimedia, NFC y Bluetooth, un navegador
web basado en Chromium, así como el desarrollo tradicional de IU.

PyQt5 es un conjunto de herramientas para crear aplicaciones con interfaz gráfica. Es una mezcla
entre Python y la biblioteca Qt. La librería Qt es una de las bibliotecas GUI más potentes.
Es desarrollado por la compañía Riverbank Computing Limited.

Se implementa como más de 35 módulos de extensión y permite que Python se use como un
lenguaje de desarrollo de aplicaciones alternativo a C ++ en todas las plataformas compatibles,
incluidas iOS y Android.
 Clases
Las clases de PyQt están divididas en varios módulos:
• QtCore
• QtGui
• QtNetwork
• QtSql

QtCore: Contiene las las funcionalidades principales que no tienen que ver con la interfaz gráfica.
Se usa para trabajar con tiempo, archivos y directorios, varios tipos de datos, flujos, urls.

QtGui: Contiene los componentes gráficos y sus clases relacionadas. Por ejemplo, botones,
ventanas, barras de estado, barras de herramienta, deslizadores, mapas de bit, colores y fuentes.

QtNetwork: Contiene las clases para programación en redes. Estas clases facilitan la programación
de clientes y servidores de tipo TCP/IP y UDPT haciendo que sea más fácil y más portable nuestro
código.

QtSql: Nos provee de clases para trabajar con bases de datos.

3.- Programación con PyQGIS

• Capas vectoriales y capas Ráster
Agregar una Capa Vectorial (Script_1.py)

layer =QgsVectorLayer("D:/Curso_ProgramacionQgis/Insumos/Shapes/estados.shp","Estados","ogr")
#Crea objeto Layer
if not layer.isValid(): #si el layer es valido lo carga a Qgis
print ("Error al cargar la capa!")
else:
QgsProject.instance().addMapLayer(layer)#Carga el Objeto a Qgis

Agregar Una Capa Raster (Script_2.py)

# -*- coding: utf-8 -*-
from PyQt5.QtCore import QFileInfo

#Objeto QFileInfo que contenga la ruta desde donde el proyecto será cargado
fileName = "D:/Curso_ProgramacionQgis/Insumos/Raster/wsiearth.tif"
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName() # Devuelve el nombre base del archivo sin la ruta
mylayer = QgsRasterLayer(fileName, baseName) #Crea un Objeto Raster

QgsProject.instance().addMapLayer(mylayer)
 Obtener Información de Una Capa Activa en Qgis (Script_3.py)

1. Información de una capa activa

layer=None
layer = qgis.utils.iface.activeLayer()
print ('Nombre de la capa : '+layer.name())
print ('Ubicacion : '+ layer.source())

2. Información de una capa activa por su nombre en Qgis

layerList = QgsProject.instance().mapLayersByName('Estados')
print ('layer : '+layerList[0].name())
print ('Ubicacion : '+layerList[0].source())

3. Información de las capas cargadas en Qgis

for lyr in QgsProject.instance().mapLayers().values(): #Lista de Layers cargadas
print ('layer : '+lyr.name())
print ('Ubicacion : '+lyr.source())

• Herramientas de Geoprocesamiento
Buffer (Script_4.py)
Parámetros
Input [vector] cualquiera
Distance [número] Predeterminado: 10.0
Segments [número] Predeterminado: 5
Dissolve[booleano] Predeterminado: Falso
Output [vector]

import processing #Importa la clase para procesar

processing.runAndLoadResults("qgis:buffer",
{'INPUT': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/jalisco.shp',
'DISTANCE': 10.0,
'SEGMENTS': 5,
'DISSOLVE': False,
'OUTPUT': 'D:/Curso_ProgramacionQgis/resultados/jaliscobuffer.shp'})
 Diferencia (Script_5.py)
Parámetros
Input[vector: cualquiera]
Overlay[vector: cualquiera]
Salidas
Output [vector]

import processing #Importa la clase para procesar

processing.runAndLoadResults("qgis:difference",
{'INPUT': 'D:/Curso_ProgramacionQgis/resultados/jaliscobuffer.shp',
'OVERLAY': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/jalisco.shp',
'OUTPUT':'D:/Curso_ProgramacionQgis/resultados/jalisco_diferencia.shp'})

Intersección (Script_6.py)
import processing #Importa la clase para procesar

processing.runAndLoadResults("qgis:intersection",
{'INPUT': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/ZONA_DE_HELADAS.shp',
'OVERLAY': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/aguascalientes.shp',
'OUTPUT' : 'D:/Curso_ProgramacionQgis/resultados/ags_intersecta.shp'})

Clip (Script_7.py)

import processing #Importa la clase para procesar

processing.runAndLoadResults ("qgis:clip",
{'INPUT': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/ISOYETA.shp',
'OVERLAY': 'D:/Curso_ProgramacionQgis/Insumos/Shapes/aguascalientes.shp',
'OUTPUT': 'D:/Curso_ProgramacionQgis/resultados/ags_isoyeta.shp'})

https://docs.qgis.org/testing/en/docs/user_manual/processing_algs/qgis/index.html
 • Acceder a la estructura de la tabla de un shape (Script_8.py)
# -*- coding: utf-8 -*-
layer = QgsVectorLayer("D:/Curso_ProgramacionQgis/Insumos/Shapes/estados.shp","Estados","ogr")
print (" ---------------------------------")
print ("Listado de Campos")
print (" ")
for field in layer.fields(): #Obtener Informacion de la Estructura de la Tabla
print (field.name(), field.typeName())
print ("----------------------------------")
features = layer.getFeatures()
for feature in features:
# recuperar cada característica con su geometría y atributos
# muestra información sobre la geometría de la entidad
geom = feature.geometry()
tipogeom = geom.type()
if geom.type() == QgsWkbTypes.PointGeometry:
tipogeom = ("Punto")
elif geom.type() == QgsWkbTypes.LineGeometry:
tipogeom = ("Linea")
elif geom.type() == QgsWkbTypes.PolygonGeometry:
tipogeom = ("Poligono")
else:
print ("Unknown")
# obtener atributos
attrs = feature.attributes() # lista que contiene todos los valores de atributo de la capa
print(attrs)
print ("Tipo de poligono : ",tipogeom)
print ("Feature ID : ",feature.id())
print ("CVEGEO : " ,feature['CVEGEO'])
print ("CVE_ENT : ",feature[1])
print ("Estado : ",feature[2].encode('latin1').decode('utf-8'))
#Codificar a latin1 y decodificar a utf-8
print ("Shape Area : ",str (feature['SHAPE_AREA'] ))

• Acceso a geometría
Para acceder a la información de la geometría se utiliza el método geometry().Se puede utilizar el
método type() que devuelve un valor de enumeración QgsWkbTypes.

if(geom.type() == QgsWkbTypes.PolygonGeometry):
print “Es un Poligono”

El método QgsWkbTypes () se puede utilizar también para saber el tipo de geometría:

>>>gPnt.wkbType() == QgsWkbTypes.PointGeometry
True
>>>gLine.wkbType() == QgsWkbTypes.LineGeometry
True
>>>gPolygon.wkbType() == QgsWkbTypes.PolygonGeometry
True
Para extraer información de una geometría existen funciones de acceso para cada tipo vectorial.
Cómo usar accesos.

>>>gPnt.asPoint()
(1, 1)
>>>gLine.asPolyline()
[(1, 1), (2, 2)]
>>>gPolygon.asPolygon()
[[(1, 1), (2, 2), (2, 1), (1, 1)]]

También hay una función auxiliar isSingleType()para averiguar si una geometría es simple o
multiparte.
Para geometrias multiples existen funciones similares para accesar :

asMultiPoint(), asMultiPolyline(), asMultiPolygon().

 Script para acceder a Geometrías (Script_9.py):
# -*- coding: utf-8 -*-
layer = QgsVectorLayer("D:/Curso_ProgramacionQgis/Insumos/Shapes/estados.shp","Estados","ogr")
features = layer.getFeatures()
for feature in features:
if feature.id() == 0:
geom = feature.geometry()
geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType())

print ("Feature OID : " + str (feature.id()))

print ("Estado : ",feature[2].encode('latin1').decode('utf-8'))
print ("Informacion de la Geometria" )
print ("Area:", geom.area())
print ("Perimetro:", geom.length())

if geom.type() == QgsWkbTypes.PointGeometry:
# El tipo de geometría puede ser simple o múltiple.
if geomSingleType:
x = geom.asPoint()
print("Point: ", x)
tipoGeom = "Punto"
else:
x = geom.asMultiPoint()
print("MultiPoint: ", x)
tipoGeom = "Milti-Punto"
elif geom.type() == QgsWkbTypes.LineGeometry:
if geomSingleType:
x = geom.asPolyline()
print("Line: ", x, "length: ", geom.length())
tipoGeom = "Linea"
else:
x = geom.asMultiPolyline()
print("MultiLine: ", x, "length: ", geom.length())
tipoGeom = "Multi-Linea"
elif geom.type() == QgsWkbTypes.PolygonGeometry:
if geomSingleType:
x = geom.asPolygon()
print("Polygon: ", x, "Area: ", geom.area())
tipoGeom = "Poligono"
else:
x = geom.asMultiPolygon()
print("MultiPolygon: ", x, "Area: ", geom.area())
tipoGeom = "Multi-Poligono"
else:
print("Geometria desconocida o invalida")

break

• Operaciones de Geometría con Predicados y Operaciones

QGIS utiliza la biblioteca GEOS para operaciones avanzadas de geometría como predicados de
geometría (contains(), intersects(), ...) y operaciones de conjuntos (union(),
difference(),. ..).

También se puede calcular propiedades geométricas de geometrías, tales como el área (en el caso
de polígonos) o longitudes (por polígonos y líneas)
 • Predicados:Intersects, Touches, Disjoint, Crosses, Within, Contains, Overlaps, Equals,
Covers
• Operaciones:Union, Distance, Intersection, SymmetricDifference, Convex Hull, Envelope,
Buffer, Simplify, PolygonAssembly, Valid, Area, Lengt

Ejemplo de uso de predicados Script para determinar traslapes (Script_10.py)

Ruta de Internet para consultar los predicados y operaciones.

https://pcjericks.github.io/py-gdalogr-cookbook/geometry.html

• Conexión a Bases de Datos

# - *- coding: utf-8 - *-
from PyQt5.QtSql import *
from qgis.core import *

uri = QgsDataSourceUri()

def conexionBD():
uri.setConnection("host","puerto","bd","usuario,"pass")
db = QSqlDatabase.addDatabase("QPSQL")
if db.isValid():
db.setHostName("host")
db.setDatabaseName(uri.database())
db.setPort(int(uri.port()))
db.setUserName(uri.username())
db.setPassword(uri.password())
db.open()
return db
return None

def getClavecarta():
listado = []
db =conexionBD()
if db.open():
print ("---------- Base de Datos Abierta--------------")
uri.setDataSource("esquema","tabla","geom","filtro=''")
vlayer = QgsVectorLayer(uri.uri(), "NombreCapa", "postgres")
QgsProject.instance().addMapLayer(vlayer)
query = db.exec_("select * from esq.tabla where * = '*****' order by
* asc limit 10")
while query.next():
record = query.record()
print ("ID "+str (record.value(0)) + " NOMBRE " +
record.value(1))
llistado = listado + [record.value(1)]
db.close()
print ("----------Base de Datos Cerrada------------")
return listado

lista =getClavecarta()
4.- Construyendo un plugin de QGIS con Python
Los complementos son una excelente manera de ampliar la funcionalidad de QGIS. Puede escribir
complementos usando Python que pueden ir desde agregar un botón simple hasta kits de
herramientas sofisticados. Este tutorial describirá el proceso involucrado en la configuración de su
entorno de desarrollo, el diseño de la interfaz de usuario para un complemento y la escritura de
código para interactuar con QGIS. Por favor, revise el tutorial de Programación para comenzar con
Python para familiarizarse con los conceptos básicos.

Obtener las herramientas

Qt Designer

Qt Designer es la herramienta de Qt para diseñar y construir interfaces gráficas de usuario (GUI) con
Qt Widgets. Puede componer y personalizar sus ventanas o cuadros de diálogo de una manera que
usted ve lo que obtiene (WYSIWYG) y los prueba utilizando diferentes estilos y resoluciones.

Un editor de texto o un IDE de Python

Cualquier tipo de desarrollo de software requiere un buen editor de texto. Si ya tiene un editor de
texto favorito o un IDE (entorno de desarrollo integrado), puede usarlo para este tutorial. De lo
contrario, cada plataforma ofrece una amplia variedad de opciones gratuitas o de pago para los
editores de texto. Elige el que más se ajuste a tus necesidades.

Plugin Builder

Hay un útil complemento de QGIS llamado que crea todos los archivos necesarios y el código de
referencia para un complemento. Encuentra e instala el plugin. Consulte Uso de complementos para
obtener más detalles sobre cómo instalar complementos. PluginBuilderPlugin Builder.

Plugin Reloader

Este es otro complemento auxiliar que permite el desarrollo iterativo de complementos. Con este
complemento, puede cambiar su código de complemento y hacer que se refleje en QGIS sin tener
que reiniciar QGIS cada vez. Encuentra e instala el plugin. Consulte Uso de complementos para
obtener más detalles sobre cómo instalar complementos.Plugin Reloader.

Nota
Plugin Reloader es un plugin experimental. Asegúrese de haber marcado Mostrar también
complementos experimentales en la configuración del Administrador de complementos si
no puede encontrarlo.
Procedimiento

1. Abra QGIS. Vaya a Complementos PlugingBuilder ‣ PlugingBuilder:

2. Verá el cuadro de diálogo Plugin Builder QGIS con un formulario. Puede completar el
formulario con detalles relacionados con nuestro complemento. El nombre de la clase será
el nombre de la clase Python que contiene la lógica del complemento. Este también será el
nombre de la carpeta que contiene todos los archivos de complemento. El nombre del
complemento es el nombre bajo el cual aparecerá su complemento en el Administrador de
complementos. Agregue una descripción en el campo Descripción. El nombre del módulo
será el nombre del archivo principal de Python para el complemento. Deje los números de
versión como están e ingrese su nombre y dirección de correo electrónico en los campos
correspondientes. Haga clic en Siguiente:
 3. A continuación, se le pedirá que elija un directorio para su complemento. Debe buscar el
directorio del complemento de Python de QGIS en su computadora. La ubicación de la
carpeta dependerá de su plataforma de la siguiente manera: (Reemplace usuario con su
nombre de inicio de sesión).

Windows C:\usuario\AppData\Roaming\QGIS\QGIS3\ profiles\default\python\plugins

Mac Library/Application Support/QGIS/QGIS3
Linux local/share/QGIS/QGIS3

4. Verá un cuadro de diálogo de confirmación una vez que se haya creado su plantilla de
complemento. Tenga en cuenta la ruta a la carpeta del complemento.
5. Antes de que podamos usar el complemento recién creado, debemos compilar el
resources.qrc archivo creado por Plugin Builder. Inicie el Shell OSGeo4W en
Windows o en un terminal Mac o Linux

6. Busque el directorio de complementos donde se creó la salida de complemento recién

creado. Puede utilizar el comando seguido de la ruta al directorio.

Plugin Buildercd.

7. Una vez que estpe en el directorio, se ejecuta el comando:

pyrcc5 -o resources.py resources.qrc

Que teníamos instalado como parte de los enlaces Qt para Python.

8. Ahora estamos listos para echar un primer vistazo al nuevo complemento que creamos.
Cierre QGIS y ejecútelo nuevamente. Vaya a Complementos ‣ Administrar e instalar
complementos y habilite el complemento en la pestaña Instalado. Notará que hay un nuevo
icono en la barra de herramientas y una nueva entrada de menú.
DESARROLLO DE PLUGIN VALIDA GEOMETRIA