Clase 2

El soporte de Python se basa en las siguientes modulos:

Cada módulo tiene su respectivos códigos y usos, si se quiere profundizar más entrar a este
link:

“ http://qgis.org/api/modules.html ”

1. Cuando se quiera trabajar con códigos largos podemos hacer uso del editor:

2. Como ejemplo abriremos el archivo “Point.py” que se encuentra en la carpeta de

materiales correspondiente a la clase 2:
Observaremos que el editor carga el archivo y a la vez este puede ser editado, es una forma
fácil de escribir códigos.

3. Al final escribiremos una función separada de la clase:

“
def Gidahatari():
return "Gestion Sostenible del Agua"

“
4. Le damos al botón de “Run Script “ y ahora podemos utilizar la clase y sus atributos en
la consola:
“
g = Point()
g.draw()
Gidahatari()
“

Cabe resaltar que aparecen unos menos al lado del código que si les hacemos click,
comprimen el código:
 5. Si le damos a guardar, automáticamente se guardará nuestro archivo point.py

Proveedores
Hay variedad de proveedores en el entorno QGIS, podemos visualizarlos desde PyQGIS y
también desde la interfaz gráfica de QGIS

Empezaremos por PyQGIS:

1. Limpiamos la consola y vamos a iterar todos los proveedores

“
for provider in QgsProviderRegistry.instance().providerList():
print provider
“
Ahora vamos a utilizer la interfaz gráfica para ver los proveedores:

Help  About  Providers

Shapefile
Empezaremos cargando un shapefile:

1. Para cargar un shapefile tenemos que utilizar la función “ QgsVectorLayer “, esta

función pide 3 argumentos principales:

QgsVectorLayer(“Dirección complete del archive”, “Nombre con el que quiera ser

cargado el archive”, “Nombre del proveedor”)
 El nombre del proveedor por defecto es ogr (OpenGIS Simple Features Reference
Implementation)

g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1 Intro Python y

PyQGIS\CUENCAS_HIDROGRAFICAS", "Cuencas","ogr")

2. Ahora si queremos ver si en verdad se ha cargado el archivo y no hemos cometido

error en la ruta colocamos el código de verificación:

“ g.isValid() “
Resultando True, que significa que hemos cargado exitosamente el archivo.

3. Podemos observar que no pasa nada en el Canvas, debido a que tenemos que utilizar
otra función para visualizarlo, ya que hasta este punto lo tenemos almacenado como
una variable:
“ QgsMapLayerRegistry.instance().addMapLayer(g) “

Donde “g” es la variable donde está contenida el shapefile.

Podemos ver que automáticamente se carga el Shapefile:

4. En resúmen si queremos hacer todo en un solo paso podemos aplicar un condicional:

 “
g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1 Intro
Python y PyQGIS\CUENCAS_HIDROGRAFICAS", "Cuencas","ogr")
if g.isValid():
QgsMapLayerRegistry.instance().addMapLayer(g)
“

5. Si queremos eliminar el shapefile de Canvas y de las variable cargada ejecutamos la

función:

“ QgsMapLayerRegistry.instance().removeMapLayer(g.id()) “

En este caso si queremos cargar “g” o si queremos ver si es válido nos botará
error ya que se eliminó.
6. Ahora para modificar el color se tiene que seguir los siguientes pasos:
a) Primero creamos la variable que contiene nuestra capa
“
g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1 Intro
Python y PyQGIS\CUENCAS_HIDROGRAFICAS", "Cuencas","ogr")
“

Y si es que no se ha borrado o quitado la capa, tenemos que volver a ponerla

para visualizar el cambio:

“ QgsMapLayerRegistry.instance().addMapLayer(g) “

b) Luego aplicamos renderer:

“ renderer = g.rendererV2() “
 c) Ahora para tener la simbología:
“ symbol = renderer.symbol() “

d) Y para tener la información de la simbología escribimos:

“ symbol.dump() “

Donde los 3 primeros números separados por comas al final es el código del color en que se
encuentra en este momento respecto a RGB
e) Para cambiar de color tenemos que importar el módulo de color y escoger el
código de color HEX:
“
from PyQt4.QtGui import QColor
symbol.setColor(QColor('#44f441'))
“

Que en nuestro caso el código es de un color verde

f) Existen diversas formas de colocar el color

• QColor(’red’) #nombrándolo predefinidos
• QColor(’#ff0000’) #Código Hex
• QColor(255,0,0,255) #Código RGB y el 4to valor es la transparencia(0-255)

Hay 20 QColors predefinidos descritos por el Qt::GlobalColor, incluyendo

negro, blanco, colores primarios y secundarios, versiones más oscuras de estos
colores y tres tonos de gris. QColor también reconoce una variedad de
nombres de color; La función estática colorNames () devuelve nombres de
color QStringList que QColor conoce.

g) Para visualizar los datos tenemos que actualizar el canvas

g.setCacheImage(None) #Para que renderer no detenga la actualización

iface.mapCanvas().refresh() #Actualización del Canvas

“
g) Pero si observamos en la simbología del Panel de capas aún está con el color
anterior, por ello tenemos que actualizar esa leyenda:

“ iface.legendInterface().refreshLayerSymbology(g) “
Raster:
La implementación de rasters es parecida a la de vectores, pero la diferencia está en que no
necesita especificar el proveedor ya que todos son GDAL.

Raster = QgsRasterLayer(“Ruta del Raster”,'Nombre con el cual se impportará”)

1. Cargaremos el Raster que se encuentra en la carpeta “DEM”:

“ Raster =
QgsRasterLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase2\DEM\NDVI.tif",
"NDVI") “

Y ahora para agregarlo al Canvas es el mismo proceso que anteriormente con los
shapefiles:

“ QgsMapLayerRegistry.instance().addMapLayer(Raster) “
 2. Para remover el Raster lo hacemos del mismo modo como hicimos con los Shapefiles:

“ QgsMapLayerRegistry.instance().removeMapLayer(Raster.id()) “

Scripts Complejos
Para crear scripts que nos faciliten el trabajo, es cuestión de definir funciones que contengan
varias herramientas, para lo cual se van a utilizar librerías de PyQGIS, que esencialmente son:

 from PyQt4.QtGui import *

 from PyQt4.QtCore import *
 from qgis.core import *
 from qgis.utils import iface

Cabe resaltar que por defecto se abre solos todos a excepción del color por lo que añadiremos
PyQT4.QtGUI en nuestro código

1. Abrimos el editor, colocamos y corremos este código:

from PyQt4.QtGui import *

 g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1 Intro Python y
PyQGIS\CUENCAS_HIDROGRAFICAS\TEM_HIDRO_CUENCAS_HIDROGRAFICAS.shp",
"Cuencas","ogr")

def Cargar_capa():

QgsMapLayerRegistry.instance().addMapLayer(g)

def Cambiar_color():

active_layer = iface.activeLayer()

renderer = active_layer.rendererV2()

symbol = renderer.symbol()

symbol.setColor(QColor('#44f441'))

g.setCacheImage(None)

iface.mapCanvas().refresh()

iface.legendInterface().refreshLayerSymbology(active_layer)

def Abrir_Tabla_Atributos():

iface.showAttributeTable(iface.activeLayer())

2. Lo guardaremos dentro de nuestra carpeta a escoger, en este caso lo guardare dentro

de la Clase2  Scripts haciendo click en Save as…:

Lo guarde con el nombre de FuncionCompleja

3. Ahora pondremos en marcha el código guardado:

“ Cargar_capa() ”

4. Ahora cambiaremos el color de la capa:

“ Cambiar_color() “
5. Abrir Tabla de Atributos

“ Abrir_Tabla_Atributos() “

6. El siguiente ejercicio que haremos será modificar el código para que no sea necesario
definir cada función, si no que se cargue de frente simplemente con colocar
“Run_Script”, para ello borramos o comentamos todas las líneas que contengan
funciones y las indetaciones:

“
from PyQt4.QtGui import *
 g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1 Intro
Python y
PyQGIS\CUENCAS_HIDROGRAFICAS\TEM_HIDRO_CUENCAS_HIDROGRAFICAS.s
hp", "Cuencas","ogr")
QgsMapLayerRegistry.instance().addMapLayer(g)

active_layer = iface.activeLayer()
renderer = active_layer.rendererV2()
symbol = renderer.symbol()
symbol.setColor(QColor('#44f441'))
g.setCacheImage(None)
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(active_layer)

iface.showAttributeTable(iface.activeLayer())
“

Quedando de esta manera:

7. Guardaremos la última función creada con el nombre de Complejo:

8. Ahora convertiremos el archivo anterior a una clase, por ello abriremos

“FuncionCompleja.py” como archivo base, para ello tendremos que agregar __Init__
en la clase que lo que hace es facilitar la importación, en otras es un importador para
las demás funciones dentro de la clase, por ello como vemos más adelante
colocaremos las variables que usaremos en el resto llamadas “self.g” y “self.iface”; la
diferencia con “self” es el alcance que va a tener la variable, cuando se coloca “self” el
alcance que tiene esta dentro de la clase, en cambio si colocamos sin “self” el alcance
será el método en el que se use, en otras palabras sin “self” es una variable local.
 “
from PyQt4.QtGui import *
class ScriptClase2:
def __init__(self, iface):
self.g = QgsVectorLayer("C:\Users\Jonathan\Downloads\Pyqgis\Clase1
Intro Python y
PyQGIS\CUENCAS_HIDROGRAFICAS\TEM_HIDRO_CUENCAS_HIDROGRAFICAS.s
hp", "Cuencas","ogr")
self.iface = iface
def Cargar_capa(self):
QgsMapLayerRegistry.instance().addMapLayer(self.g)
def Cambiar_color(self):
active_layer = iface.activeLayer()
renderer = active_layer.rendererV2()
symbol = renderer.symbol()
symbol.setColor(QColor('#44f441'))
self.g.setCacheImage(None)
self.iface.mapCanvas().refresh()
self.iface.legendInterface().refreshLayerSymbology(active_layer)
def Abrir_Tabla_Atributos(self):
self.iface.showAttributeTable(iface.activeLayer())
def Correr_Script(iface):
m = ScriptClase2(iface)
m.Cargar_capa()
m.Cambiar_color()
m.Abrir_Tabla_Atributos()
“

9. Una vez colocado el código, lo guardamos con el nombre de ComplejoClases.

10. Y para correr la clase le damos a “Run Script” y en la consola primero correremos
nuestra clase en la consola, se creará en función de iface con el fin de no tener
necesidad de llamarla después:

“ c = ScriptClase2(qgis.utils.iface) “

O también podemos utilizar simplemente

“c = ScriptClase2(iface)”

11. Ahora podemos utilizarla como deseemos:

“ c.Cargar_capa() ”
“ c.Cambiar_color() “
“ c.Abrir_Tabla_Atributos() “