Módulo 9 Curso de QGIS La Guía de Procesamiento de QGIS

1
MÓDULO 9. La guía de procesamiento de QGIS
MÓDULO 9
Curso de QGIS
La guía de procesamiento de QGIS
José Carlos Martínez Llario
Revisión: 22/07/2020
2
Contenido
La guía de procesamiento de QGIS ............................................................................................... 3

12.1 Introducción ............................................................................................................................. 3
12.2 Caja de herramientas de procesado ....................................................................................... 3
12.3 Ejecutar nuestro primer algoritmo ........................................................................................... 4
12.4 Más algoritmos y tipos de datos .............................................................................................. 6
12.4.1 Almacenamiento permanente en un directorio seleccionado ......................................... 9
12.5 SRCs: Reproyectando ........................................................................................................... 10
12.6 Selección ............................................................................................................................... 13
12.6.1 Realizar una selección utilizando la caja de procesamiento ......................................... 14
12.7 Ejecución de algoritmos externos ......................................................................................... 15
12.8 El registro de procesamiento ................................................................................................. 17
12.8.1 Ejecutando un algoritmo desde código ......................................................................... 18
12.9 Calculadora ráster. Valores sin dato (no-data) ..................................................................... 19
12.9.1 Tipo del ráster de salida ................................................................................................ 23
12.9.2 ¿Qué calculadora ráster utilizar? .................................................................................. 25
12.10 Calculadora de campos ..................................................................................................... 26
12.11 Definición de extensiones ................................................................................................. 28
12.12 Salida en HTML ................................................................................................................. 29
12.13 Primer ejemplo de análisis sencillo ................................................................................... 31
12.14 Recortar y unir capas raster .............................................................................................. 35
12.14.1 Mapa de pendientes .................................................................................................. 40
12.15 Análisis Hidrológico ........................................................................................................... 42
12.16 Comenzando con el modelador gráfico............................................................................. 49
12.17 Modelos más complejos .................................................................................................... 55
12.18 Cálculos numéricos en el modelador ................................................................................ 58
12.19 Un modelo dentro de otro .................................................................................................. 60
12.20 La interpolación ................................................................................................................. 63
12.21 Más interpolación .............................................................................................................. 67
12.22 Ejecución iterativa de algoritmos....................................................................................... 72
12.23 Más ejecución iterativa de algoritmos ............................................................................... 74
12.24 La interfaz de procesamiento por lote ............................................................................... 75
12.25 Modelos con procesamiento por lote ................................................................................ 78
3
La guía de procesamiento de QGIS

Nota
Este módulo ha sido aportado por Victor Olaya *
* Revisado, ampliado, mejorado y traducido por José Carlos Martínez
12.1 Introducción
Esta guía describe cómo usar el marco de procesamiento de QGIS. Se asume que no se tiene ningún
conocimiento previo del marco de procesamiento o cualquiera de las aplicaciones de los que depende.
Supone un conocimiento básico de QGIS.
La guía se diseñó para el auto estudio o utilizarse para ejecutar un taller de procesamiento.
Los ejemplos en este manual utilizan QGIS 3.8-3.10. Puede ser que no funcionen exactamente igual o
no estén disponibles en versiones distintas.
Esta guía está compuesta de un conjunto de pequeños ejercicios de complejidad progresiva. Si nunca
ha usado el marco de procesamiento, debe comenzar desde el principio. Si tiene alguna experiencia
previa no dude de saltar lecciones. Las lecciones son bastante independientes entre sí y cada una
presenta un concepto nuevo o un nuevo elemento, que se indica en el título del capítulo y la breve
introducción al inicio de cada capítulo. El objetivo es hacer más fácil la localización de las lecciones que
tratan de un tema en particular.
Para una descripción más sistemática de todos los componentes del marco y su uso, se recomienda
revisar el capítulo correspondiente en el manual de QGIS. Es una buena idea, usar dicho manual como
un texto de ayuda a lo largo de esta guía.
12.2 Caja de herramientas de procesado

La instalación y uso de la caja de procesos ya se vio en el módulo anterior.
La caja de herramientas de procesado es un componente núcleo de QGIS, lo que significa que, si se
ejecuta QGIS 3.x o superior, ya debería estar instalado en tu sistema, ya que está incluido en QGIS.
En caso de que este activo, deberías ver un menú llamado “Procesado” en la barra de menú. Allí
encontrarás un acceso a todos los componentes de la caja de herramientas.
En el caso de que no aparezca el correspondiente menú de procesado Procesos, repasa el apartado
9.1.1 del módulo 7 donde se vio como activar el complemento.
Nota
Al haber utilizado ya la caja de procesos en módulos previos, posiblemente en este apartado
repetiremos algunos algoritmos, aunque usaremos otros nuevos y también algunos de los algoritmos
ya vistos los ejecutaremos pero utilizando diferentes herramientas externas. Con frecuencia QGIS
dispone de un mismo algoritmo implementado de diferentes formas y con diferentes bibliotecas, la
práctica nos dirá qué algoritmo se ejecuta más rápidamente o cual dispone de más opciones.
4
12.3 Ejecutar nuestro primer algoritmo

Resumen
En esta lección, ejecutaremos nuestro primer algoritmo y conseguiremos nuestro primer resultado.
Como ya hemos mencionado, el framework (caja o marco de trabajo) de procesamiento puede ejecutar
algoritmos de otras aplicaciones (SAGA, GDAL, etc.), pero también contiene algoritmos nativos que no
necesitan software externo a ejecutar. Para comenzar a explorar el framework de procesamiento,
vamos a ejecutar uno de esos algoritmos nativos.
 Abra el proyecto de QGIS correspondiente a esta lección situado en la carpeta (processing

/ example1) con los datos que se utilizarán en esta lección. Contiene una sola capa con dos
polígonos.
Ahora ve al cuadro de texto en la parte superior de la caja de herramientas. Ese es el cuadro de
búsqueda, y si escribes texto en ella, se filtrará la lista de algoritmos de modo que se muestren
sólo aquellos conteniendo el texto introducido. Escribe Polygons to lines o Polígonos a
líneas.
Los nombres de los algoritmos siempre se pueden buscar en inglés, además en muchos casos
aparecen también traducidos al español y también se pueden buscar en este idioma:
Fíjate que en este caso se han encontrado dos algoritmos con un nombre con un significado similar
que además realizan el mismo análisis, pero uno es un algoritmo nativo de QGIS y el otro es del
programa externo SAGA (que se habrá instalado con QGIS por defecto en MS Windows).
 En este caso vamos a utilizar el algoritmo de QGIS nativo. Haz doble clic en él.
5
Todos los algoritmos tienen una interfaz similar, que básicamente contiene los parámetros de entrada
que hay que rellenar, y las salidas que tienes que seleccionar dónde almacenar. En este caso, las
únicas entradas que tenemos son una capa vectorial.
 Seleccione polygons como capa como entrada.

El algoritmo tiene una única salida, que es la capa de líneas creada a partir de los contornos de los
polígonos. Hay dos opciones para definir donde se guarda una salida de datos: introducir una ruta
de archivo o guardarlo en un nombre de archivo temporal
En caso de que quiera establecer un destino y no guardar el resultado en un archivo temporal, el formato
de la salida está definido por la extensión de nombre de archivo. Para seleccionar un formato, sólo
tienes que seleccionar la extensión de archivo correspondiente (o añadirlo si está escribiendo
directamente la ruta de archivo en su lugar). Si la extensión de la ruta de archivo que ha introducido no
coincide con ninguno de los admitidos, una extensión por defecto (normalmente .dbf para
tablas, .tif para capas raster y .shp para los vectoriales en formato shape, .gpkg para
vectoriales en formato geopackage) se añadirá a la ruta de archivo y el formato de archivo
correspondiente a esa extensión se utilizará para guardar la capa o tabla.
En todos los ejercicios de esta guía, vamos a guardar los resultados en un archivo temporal, ya que no
hay necesidad de guardarlos para un uso posterior. Puedes sin embargo guardarlos en un lugar
permanente si quieres.
Nota
Tenga en cuenta que los archivos temporales se borran una vez que cierre QGIS. Si crea un proyecto
con una producción que se guardó como una salida temporal, QGIS se quejará cuando intenta abrir la
espalda al proyecto más adelante, ya no existirá ese archivo de salida.
 Una vez que haya configurado el diálogo algoritmo, pulse Ejecutar para ejecutar el algoritmo:
Cuando ejecutes un algoritmo comprueba también en la tabla de atributos de la capa resultante, en

este caso fíjate como se han conservado los atributos de la capa de polígonos original.
La salida tiene el mismo SRC como la capa de entrada. La gran mayoría de los algoritmos asumen que
todas las capas de entrada comparten el mismo SRC y no realizan ninguna reproyección. Excepto en
el caso de algunos algoritmos especiales (por ejemplo, el algoritmo de reproyección, o en las últimas
versiones de QGIS también algunos algoritmos de análisis espacial).
6
 Prueba tú mismo a guardarlo utilizando formatos de archivo diferentes (usa por

ejemplo, shp, .gpkg y GeoJSON como extensiones). Además, si no deseas que la capa
sea cargada en QGIS después de que se genere, puedes cambiar la casilla de verificación
que se encuentra debajo del cuadro de ruta de salida.
 Utiliza ahora otro algoritmo nativo de QGIS para convertir la capa de polígonos a una capa
de puntos conteniendo los vértices de los polígonos y también sus atributos. Deja la salida de
datos también en temporal.
Si no encuentras el algoritmo trata de buscarlo en la sección de Geometría Vectorial de la caja de
herramientas dentro de los algoritmos de QGIS.
 Abre la tabla de atributos y comprueba los resultados:
Realiza una captura de pantalla de QGIS parecida a la imagen superior donde aparezca la tabla de
atributos. Pega la imagen en la plantilla de resultados.
12.4 Más algoritmos y tipos de datos

Resumen
En esta lección vamos a probar tres algoritmos más, aprender a utilizar otros tipos de entrada, y
configurar las salidas para guardar los datos en una carpeta determinada automáticamente.
Para esta experiencia vamos a necesitar una tabla y una capa de polígonos. Vamos a crear una capa
de puntos basada en coordenadas de una tabla y, a continuación, contar el número de puntos en cada
polígono.
 Abre el proyecto de QGIS correspondiente a esta lección situado en la carpeta (processing /
example2).
Encontrarás una tabla con coordenadas X e Y, pero no se puede encontrar ninguna capa de
polígonos. No te preocupes, vamos a crear dicha capa utilizando un geoalgoritmo de
procesamiento.
Lo primero que vamos a hacer es crear una capa de puntos de las coordenadas en la tabla, usando el
algoritmo Capa de puntos a partir de tabla (points layer from table). Ahora ya sabes cómo utilizar el
cuadro de búsqueda, por lo que no debería ser difícil encontrarlo. Haz doble clic en él para ejecutarlo y
abrir su cuadro de diálogo (imagen inferior).
7
Este algoritmo, como el de la lección anterior, simplemente genera una única salida, y tiene tres
entradas:
 Tabla: la tabla con las coordenadas. Selecciona aquí la tabla alfanumérica de los datos de la
lección.
Campos X e Y: Campos de la tabla alfanumérica que contienen las coordenadas de los

puntos. Selecciona XCOORD para el campo de la X y YCOORD para el campo de la Y.
 SRC objetivo: Este algoritmo no toma el SRC de las capas de entrada. En su lugar, se pide que
selecciones manualmente el SRC de las coordenadas de la tabla.
Haz clic en el botón de la parte derecha para abrir el selector de QGIS de los SRC y selecciona
EPSG:4326 . Estamos utilizando este SRC, porque sabemos que las coordenadas de la tabla
vienen georreferenciadas con él.
 Ahora pulsa Ejecutar para obtener la capa.
Lo siguiente que necesitamos es la capa de polígonos. Vamos a crear una cuadrícula regular de
polígonos utilizando el algoritmo Crear cuadrícula (create grid), que tiene el diálogo de parámetros de
la imagen siguiente:
8
 Seleccione rectángulo (polígono) en el tipo de cuadrícula.
 Como en el caso del último algoritmo, tenemos que entrar en el CRS aquí también. Seleccione
EPSG: 4326 como el CRS de destino, como lo hicimos antes.
 En Extensión de la cuadrícula, haz clic en el botón de la

derecha y selecciona Usar extensión de la capa.. y elige
la capa recién creada de puntos.
Las demás entradas necesarias para crear la cuadrícula son numéricas. Cuando hay que introducir un
valor numérico en cualquier algoritmo de la caja de procesado, se tienen dos opciones: escribir
directamente en la casilla correspondiente o haciendo clic izquierdo sobre el botón al final de la línea
para llegar a un diálogo como el que se muestra a continuación.
 Como espaciado vertical y horizontal escribe 0,0001 .
 Presiona Ejecutar y obtendrás la capa de retícula.

Si como es el caso de la imagen de la derecha,
aparecen algunos puntos justo en la línea límite de la
cuadrícula vuelve crear la cuadrícula, pero esta vez en
Extensión de la cuadrícula elige Seleccionar
extensión sobre el lienzo y marca de forma
manual unos límites un poco más grandes.
Finalmente queremos una cuadrícula más o menos así,

es decir, que cubra de sobra todos los puntos de capa.
9
El último paso es contar los puntos en cada uno de los rectángulos de esa retícula. Vamos a
utilizar el geoproceso Contar puntos en polígono (count points in polygon) .
 Abre la tabla de atributos de la nueva capa añadida y comprueba como el campo NUMPOINTS
contiene el número de puntos de cada polígono.
12.4.1 Almacenamiento permanente en un directorio

seleccionado
Antes de terminar esta lección, te damos un consejo rápido para hacer tu vida más fácil en caso de que
quieras guardar los datos de forma permanente.
Si deseas que todos los archivos de salida se guarden en una carpeta determinada, no hace falta
escribir el nombre de la carpeta cada vez.
 En lugar de ello, desde el menú Configuración ‣ Opciones, pestaña Procesos y en la

sección General aparece la Carpeta de salida.. Se abrirá el diálogo de configuración.
Cambia la carpeta de salida a por ejemplo: c:\exercise_data\processing\results
10
Ahora cuando al ejecutar un algoritmo, en la capa de salida, sólo tiene que utilizar el nombre de archivo
en lugar de la ruta completa.
Por ejemplo, con la configuración mostrada anteriormente, si introduce grid.shp como la ruta de
salida para el algoritmo que acabamos de utilizar, el resultado se guardará
en c:\exercise_data\processing\results\grid.shp . Todavía se puede introducir una ruta
completa en caso de querer un resultado que se guarda en una carpeta diferente.
 Prueba tú mismo de nuevo el algoritmo Create Grid con diferentes tamaños de cuadrícula,
escribiendo en el fichero de salida directamente el nombre y comprueba como se crea dicho
fichero de salida en el directorio results .
12.5 SRCs: Reproyectando

Resumen
En esta lección vamos a discutir cómo los algoritmos de procesamiento utilizan los SRC. También
veremos un algoritmo muy útil: reproyectar.
El manejo de los SRC suele ser una fuente de confusión para los no expertos en cartografía (Ingenieros
en Geodesia, en Geomática y Topografía), así que aquí están algunas reglas generales sobre la forma
en que son manejados por los geoalgoritmos de la caja de procesos al crear una nueva capa.
 Si hay varias capas de entrada, QGIS utilizará el CRS de la primera capa. Los algoritmos de
procesamiento asumirán que todas las capas de entrada tienen el mismo SRC que la primera capa.
 Si utiliza capas con distinto SRS, QGIS te advertirá de ello. Observa que el SRS de las capas de
entrada se muestra junto a su nombre en el cuadro de diálogo parámetros, lo cual siempre es una
ayuda y puede hacer que te des cuenta de un posible error.
Si no hay ninguna capa de entrada, se utilizará el SRC del proyecto de QGIS, a menos que el
algoritmo contenga un campo específico de SRC de salida (como pasó en la última lección con el
algoritmo de cuadrícula)
 Abre el proyecto correspondiente a esta lección (example3) y verás dos capas con el nombre
23030 y 4326 .
Ambos contienen los mismos puntos, pero en diferente SRC ( EPSG:23030 y EPSG:4326 ).
Los puntos aparecen exactamente en la misma posición del terreno porque QGIS es capaz de
reproyectar en tiempo real todas las capas al SRC del proyecto, que en este caso es el EPSG:
4326, pero no son en realidad la misma capa. Es decir, los números de las coordenadas de los
puntos son totalmente diferentes.
11
 Abre el algoritmo Agregar atributos de geometría (Add geometry attributes) :
Este algoritmo añade nuevas columnas a la tabla de atributos de una capa vectorial. El contenido de
las columnas depende del tipo de la geometría de la capa. En el caso de los puntos, añade nuevas
columnas con la coordenadas X e Y de cada punto.
Nota
Acuérdate que esto mismo lo hacíamos desde la calculadora de campos en módulos anteriores.
 Selecciona como Capa de entrada la capa 4326.
El otro parámetro del algoritmo ( calcular usando ) permite establecer cómo el algoritmo utiliza las
coordenadas para calcular el nuevo valor que va a añadir a las capas resultantes. La mayoría de los
algoritmos no tienen una opción así, y sólo utilizan las coordenadas de la capa directamente.
 Selecciona la opción SRC de la capa que simplemente utilizará las coordenadas como
son. Así es como funcionan por defecto casi todos los geoalgoritmos de QGIS de la caja de
procesado.
Habrás obtenido una nueva capa con exactamente los mismos puntos que la otra dos capa. Si abres
las propiedades de la nueva capa, verás que utiliza el mismo SRC que la capa de entrada, es decir, el
EPSG: 4326. Cuando la capa se carga en QGIS, no se le pedirá que introduzca el SRC de la capa, ya
que QGIS ya lo sabe.
 Abre la tabla de atributos de la nueva capa y comprueba que contiene dos nuevos campos
con las coordenadas X e Y de cada punto
 Ahora repite el algoritmo pero con la otra capa, seleccionaremos como entrada la capa
23030 y la misma de opción de SRC de la capa
12
La tabla de atributos muestra valores diferentes de coordenadas lo que demuestra que originalmente
las coordenadas estaban en distinto SRC.
¿Qué debe aprender de esto? La idea principal detrás de estos ejemplos es que los geoalgoritmos
utilizan el SRC de la capa, ya que son los datos originales, e ignoran por completo las reproyecciones
que QGIS podría estar haciendo para renderizar (es decir, la proyección del proyecto).
En otras palabras, no hay que confiar en lo que se ve en el lienzo, y siempre tener en cuenta que se
utilizarán las coordenadas originales. Eso no es tan importante en este caso, ya que sólo estamos
usando una sola capa a la vez, pero en un algoritmo que necesita varias de ellas (por ejemplo, un
algoritmo de recorte), capas que parecen coinciden o superponerse pueden ser muy lejos unas de otras
(en coordenadas originales, que son las que utilizará el geoalgoritmo), ya que podrían tener diferentes
SRC.
El geoalgoritmo de QGIS Reproyectar capa (reproject layer) representa un caso particular del
comportamiento explicado, ya que tiene una capa de entrada (la que se desea reproyectar), pero no va
a usar el mismo SRC para la capa de salida, sino que va a solicitar un SRC nuevo, al cual reproyectar
la capa (y por tanto CAMBIAR sus coordenadas originales).
Hay otro geoalgoritmo para reproyección pero para capas ráster muy similar de GDAL y que veremos
en otro ejercicio más adelante. Se llama Combar (reproyectar) o Warpt (reproject).
 Abre el algoritmo de QGIS Reproyectar capa:
 Selecciona cualquiera de las capas como entrada y elige el EPSG:23029 como el SRC
destino. Ejecuta el algoritmo y obtendrás una nueva capa, idéntica a la de entrada, pero con
diferente SRC.
 Aparecerá en la misma región del lienzo, al igual que las demás, ya que QGIS reproyecta
sobre la marcha todas las capas al SRC del proyecto, pero sus coordenadas originales serán
diferentes. Se puede ver añadiendo las columnas de X e Y como hemos hecho anteriormente.
Otra forma mucho más rápida de comprobar qué coordenadas originales tienen las geometrías de una
capa, consiste en seleccionar uno o varios elementos y hacer clic en el menú Edición / Copiar
objetos espaciales.
13
Esto copiará al portapapeles la definición en WKT (que es un formato en texto de la geometría del
elemento) más los valores de los atributos en texto.
 Abre un editor de texto (como el bloc de notas) y pega el texto. De esta forma podrás
comprobar las coordenadas fuente de las geometrías.
Nota
El texto pegado tiene formato CSV (utilizando el tabulador como separador de columnas de atributos).
De esta forma fácilmente podrías grabar el texto del bloc de notas con la extensión .csv y abrirla con
programas como Excel o incluso QGIS (como si fuera una tabla).
12.6 Selección
Resumen
En esta lección vamos a ver cómo los algoritmos de procesamiento manejan selecciones en capas
vectoriales que se utilizan como capas de entrada, y cómo crear una selección a través de un
determinado tipo de algoritmo.
En casi todos los algoritmos de la caja de procesamiento tenemos disponible una casilla objetos
seleccionados solamente, que podemos marcar para ejecutar el proceso solo teniendo en cuenta los
objetos actualmente seleccionados en la capa de entrada.
Los algoritmos siguen las siguientes reglas simples cuando se utiliza una capa vectorial:
 Si la capa tiene una selección, la casilla objetos seleccionados solamente aparecerá disponible, y
permitirá al usuario marcar o desmarcar dicha casilla para.
 Si no hay selección, todos los objetos espaciales se utilizan y la casilla objetos seleccionados
solamente aparecerá no disponible.
 Si la capa vectorial de entrada no se ha cargado previamente en QGIS (no forma parte de la lista
de capas del proyecto), no se podrá realizar una selección Fíjate que en la siguiente imagen
donde capa 4326.shp no está en la lista de capas, es decir, se ha seleccionado directamente en
el disco duro, y por tanto como es lógico no se puede aplicar a los objetos seleccionados, y la
casilla objetos seleccionados solamente aparecerá bloqueada.
Puedes probar tú mismo a seleccionar algunos puntos en cualquiera de las capas (de la lista de capas
del proyecto) que utilizaste en el ejercicio anterior, y al ejecutar el algoritmo de la reproyección marca
la casilla objetos seleccionados solamente. La capa reproyectada que se obtendrá contendrá sólo esos
puntos que se seleccionaron.
14
12.6.1 Realizar una selección utilizando la caja de

procesamiento
Para hacer una selección, puede utilizar cualquiera de los métodos y herramientas disponibles en
QGIS, como la selección manual utilizada hasta ahora:
Sin embargo también se puede utilizar un geoalgoritmo para hacerlo. Los algoritmos para la creación
de una selección se encuentran en la sección Selección vectorial de la caja de herramientas:
 Abre el algoritmo Selección aleatoria (random

Selection)
 Deja los valores con la imagen inferior, se

seleccionará 5 puntos de la capa actual
Te habrás dado cuenta que este algoritmo no produce ninguna salida, y que modifica la selección de
la capa de entrada.
Dado que la selección no es parte de los datos en sí, sino algo que solo existe dentro de QGIS, estos
algoritmos de selección sólo deben utilizarse seleccionando una capa que se abre en QGIS, y no con
la opción de selección de archivo que se puede encontrar en el cuadro de valor de parámetro
correspondiente.
15
La selección que hemos hecho, como la mayoría de los creadas por el resto de algoritmos de selección,
también se puede hacer manualmente desde QGIS, por lo que puede preguntarse, ¿cuál es el objetivo
de utilizar un algoritmo para realizar una selección?
Aunque ahora mismo no tiene mucho sentido, más adelante veremos cómo crear modelos y scripts. Si
se desea hacer una selección en medio de un modelo (que define un flujo de trabajo de procesamiento),
sólo un geoalgoritmo se puede añadir al modelo, y otros elementos de QGIS y operaciones no se
pueden añadir. Esa es la razón por la que algunos algoritmos de procesamiento duplican funcionalidad
que también está disponible en otros elementos de QGIS.
Por ahora, sólo recuerda que las selecciones se pueden hacer usando geoalgoritmos de
procesamiento, y que los algoritmos sólo utilizarán los objetos espaciales seleccionados si existe una
selección y se marca la correspondiente casilla.
12.7 Ejecución de algoritmos externos

Resumen
En esta lección vamos a ver cómo utilizar algoritmos que dependen de una aplicación de terceros,
sobre todo SAGA, que es uno de los principales proveedores externos de algoritmos.
Todos los algoritmos que hemos ejecutado hasta ahora en este módulo son parte del framework de
procesamiento. Es decir, que son algoritmos nativos implementados en QGIS.
Sin embargo, una de las mayores características del framework de procesamiento es que puede utilizar
algoritmos de aplicaciones externas y ampliar las posibilidades de esas aplicaciones. Estos algoritmos
se convierten y se incluyen en la caja de herramientas, por lo que se pueden utilizar fácilmente en
QGIS.
Estos algoritmos externos requieren que ciertas aplicaciones sean instaladas en tu sistema, aunque si
has instalado QGIS en MS Windows, automáticamente se instalan también algunas de estas
aplicaciones externas como GRASS, SAGA o GDAL.
Si estás utilizando MS Windows, la mejor manera de trabajar con algoritmos de proveedores externos
es la instalación de QGIS usando el instalador independiente como seguramente hayas realizado en el
curso. En tal caso, el proceso de la instalación de todas las dependencias necesarias, incluyendo
SAGA, GRASS, GDAL, etc., y no hay nada más que realizar.
 Abre la configuración de los Procesos y haz clic en la sección de Proveedores.
Un proveedor de algoritmos de especial interés es SAGA (Sistema Automatizado de Análisis

Geoespacial). En primer lugar, tenemos que configurar las herramientas de procesado para que QGIS
puede comunicarse correctamente con SAGA.
16
¿Linux u OSX? En caso de que esté utilizando Linux o OSX debe instalar SAGA de forma independiente
y asegurarse de que la carpeta SAGA está en path del sistema, por lo que se puede llamar desde la
consola (sólo tienes que abrir una consola y ejecutar el comando saga_cmd para comprobarlo).
 Prueba con un algoritmo basado en SAGA, el llamado Split shapes layer randomly
Vamos a seguir con las capas de puntos utilizada en las dos prácticas anteriores.
 Elige un porcentaje de 50% y ejecuta el algoritmo.
La capa de entrada se ha dividido en dos capas, cada una con el mismo número de puntos. Este
resultado ha sido calculado por SAGA, y más tarde importado por QGIS y añadido al proyecto de QGIS.
Si todo va bien, no notarás ninguna diferencia entre este algoritmo basado en SAGA y uno de los otros
que hemos ejecutado anteriormente (nativos de QGIS).
Sin embargo, SAGA podría, por alguna razón, no ser capaz de producir un resultado y no generar el
archivo que QGIS está esperando. En ese caso, habrá problemas para añadir el resultado del proyecto
de QGIS, y un mensaje de error.
Este tipo de problemas puede ocurrir, incluso si SAGA (o cualquier otra aplicación que estamos
llamando desde el framework de procesado) se ha instalado correctamente, y es importante saber cómo
tratar con ellos. Vamos a producir uno de los mensajes de error.
 Abre el algoritmo de SAGA Create polygons graticule y utiliza los siguientes valores. Fíjate
como introducimos un valor negativo en el ancho de la división. Esto provocará un fallo en
SAGA:
17
Estamos utilizando unos valores de división de anchura y altura que son más grandes que la extensión
especificada, por lo SAGA no puede producir ninguna salida. En otras palabras, los valores de los
parámetros están mal, pero no se comprueban hasta que SAGA trata de crear la capa de salida. Como
no puede producir la capa aparecerá el siguiente mensaje de error:
La comprensión de este tipo de problemas le ayudará a resolverlos y encontrar una explicación a lo

que está sucediendo. Puedes obtener más información del error consultando el panel de mensajes
de registro.
En la próxima lección vamos a introducir los mensajes de registro de procesamiento, donde se guarda
información sobre los comandos dirigidos por los geoalgoritmos, y verás cómo obtener más detalles
cuando aparece algún problema.
12.8 El registro de procesamiento

Todos los mensajes producidos en el análisis realizado con la caja de procesos se registra con su
propio sistema de registro.
Esto permite saber más sobre lo que ha ocurrido con las herramientas de procesamiento, para resolver
los problemas cuando se producen, y también para volver a ejecutar los algoritmos anteriores, ya que
el sistema de registro también implementa cierta interactividad.
 Para abrir el registro, seleccione la entrada del menú Procesos > Historial…Verás el siguiente
cuadro:
18
En la sección Algorithm aparecen todos los algoritmos que se ejecutan, incluso si se ejecutan desde
la GUI (interfaz gráfica de QGIS) y no desde la consola (que se explicará más adelante en este manual),
se almacenan en esta parte del registro como una llamada de un comando de la consola.
Eso significa que cada vez que se ejecuta un algoritmo, se añade un comando de consola en el registro,
y puedes comprobar el historial completo de la sesión de trabajo.
- Esto puede ser muy útil cuando se utilizan los comandos desde la consola, para
aprender acerca de la sintaxis de los algoritmos.
- El historial también es interactivo, y se puede volver a ejecutar cualquier algoritmo
anterior simplemente haciendo doble clic sobre su entrada.
Además también aparecen muchos mensajes de registro de Python, de la caja de procesos y de

bibliotecas externas que utiliza QGIS como GDAL, en el panel de registro, menú Ver > Paneles >
Mensajes de registro:
12.8.1 Ejecutando un algoritmo desde código

También es posible modificar los parámetros de un algoritmo ejecutado anteriormente.
 Abre de nuevo el historial de procesos, y haz clic en el proceso de selección aleatoria ejecutado
anteriormente. Debajo del historial aparecerá el comando completo que se ha utilizado para dicho
proceso. Cópialo al portapapeles:
processing.run("qgis:randomselection",
{'INPUT':'C:/exercise_data/processing/example3/23030.shp','METHOD':0,'NUMBER':5})
 Abre el menú Complementos ‣ Consola de Python
 A continuación copia el comando anterior (en la línea >>> de debajo de la ventana) y presiona
enter:
19
 Después de presionar enter, se ejecutará el comando y se seleccionarán los 5 puntos de la capa

23030.
12.9 Calculadora ráster. Valores sin dato (no-data)

Resumen
En esta lección vamos a ver cómo utilizar la calculadora ráster para realizar algunas operaciones en
capas ráster. También vamos a explicar cuáles son los valores correspondientes a no-data y como la
calculadora y otros algoritmos interpretan estos valores.
La calculadora ráster es uno de los algoritmos más potentes que encontrarás. Es un algoritmo muy
flexible y versátil que se puede utilizar para muchos cálculos diferentes, y que pronto se convertirán en
una parte importante de tu caja de herramientas.
En esta lección vamos a realizar algunos cálculos con la calculadora ráster, la mayoría de ellos bastante
simple. Esto nos permitirá ver cómo se utiliza y cómo soluciona algunas situaciones particulares que
podrías encontrar para comprender ciertas técnicas que se aplican habitualmente.
 Abre el proyecto de QGIS correspondiente a esta lección (example4) y verás que contiene
varias capas ráster.
 Ahora abre la caja de herramientas y abre el diálogo correspondiente al algoritmo Calculadora
ráster (Raster Calculator).
 Fíjate que puede haber varios algoritmos similares, en

este caso, tenemos tres Raster Calculator, el
implementado por QGIS (accesible también desde el
menú Ráster > Calculadora Ráster), GDAL y el
implementado por SAGA (Si no encuentras el de SAGA
pon el texto del algoritmo en inglés para su búsqueda).
 Vamos a Utilizar la versión de SAGA
20
El diálogo contiene varios parámetros:
 Las capas a utilizar para el análisis. Hay una primera capa principal (Main input layer). Si el
algoritmo utiliza más de una capa, entonces podemos ponerlas en la casilla de Additional layers
que es de selección múltiple.
 La fórmula a aplicar. La fórmula utiliza las capas seleccionadas en el parámetro anterior, que se
nombran usando letras del alfabeto (a, b, c, etc. ) o g1, g2, g3, etc. como nombres
de variables. Es decir, la fórmula a + 2 * b es lo mismo que g1 + 2 * g2 y calculará la
suma del valor en la primera capa más dos veces el valor en la segunda capa. El orden de las
capas es el mismo orden que se ve en el cuadro de diálogo de selección.
Advertencia
La calculadora es sensible a mayúsculas.
Para empezar, vamos a cambiar las unidades del MDE de metros a pies. La fórmula que necesitamos
es la siguiente: h'= h * 3.28084
 Selecciona el MDE (capa dem25 ) en la casilla Main input layer y escribe a * 3.28084 en el
campo de Fórmula.
Advertencia
Para los usuarios ingleses: utilizar siempre “,” en lugar de “.” en la separación del punto decimal
 La capa de entrada que utilizamos tiene valores válidos en todas sus celdas, por lo que la casilla
Use NoData no tiene ningún efecto en absoluto.
 Haga clic en Ejecutar para ejecutar el algoritmo. Se creará una capa que tiene la misma
apariencia de la capa de entrada, pero con diferentes valores.
Ahora vamos a realizar otro cálculo, esta vez con la capa accflow. Esta capa contiene los valores de
flujo acumulado, un parámetro hidrológico. Contiene los valores sólo dentro del área de una cuenca
determinada, con valores de no-data fuera de ella.
Como puedes apreciar la visualización de la capa no es muy representativa debido a como se

distribuyen los valores. Utilizando el logaritmo de los valores obtendremos una distribución mejor de los
valores para su visualización, así que vamos a utilizar la calculadora ráster para obtener una nueva
capa que sea el algoritmo de accflow
21
 Abre el diálogo algoritmo nuevo, selecciona la capa accflow como la única capa de entrada,
e introduce la siguiente fórmula: log (a) .
Aquí está la capa que conseguirás:
 Selecciona la herramienta de identificar para

conocer el valor en un punto dado de la capa que
acabamos de crear, y haz clic en un punto
ligeramente fuera de la cuenca.
 Verás que contiene un valor de no-data.
Para el siguiente ejercicio vamos a utilizar dos capas en lugar de una. El objetivo es obtener una nueva
capa DEM a partir de la capa dem25 pero que se restringa a los límites de la capa accflow, es decir
con valores de elevación válidos sólo dentro de la cuenca que se define en la segunda capa.
 Abre el diálogo calculadora y selecciona las dos capas del proyecto en el campo de las capas
de entrada (accflow como Main input layer). Escriba la fórmula siguiente en el campo
correspondiente: a / a * b
a se refiere a la capa de flujo acumulado accflow (ya que es la primera en aparecer en la lista)
y b se refiere a la dem25.
Lo que estamos haciendo en la primera parte de la fórmula es dividir la capa de flujo acumulado por sí
misma, lo que resultará en un valor de 1 en el interior de la cuenca, y un valor no-data fuera.
Luego multiplicamos por el dem25, para obtener el valor de elevación en esas células en el interior de
la cuenca (DEM * 1 = DEM) y el valor sin datos fuera (DEM * NO_DATA = NO_DATA)
Aquí está la capa resultante:

22
Esta técnica se utiliza con frecuencia para aplicar máscaras en una capa ráster, y es útil cuando se
desea realizar cálculos para una región distinta que la región rectangular que se utiliza por defecto en
una capa ráster.
Hay otras cosas interesantes acerca de este algoritmo que acabamos de ejecutar, además de los
valores no-data y la forma en que se manejan. La extensión de las capas de entrada eran diferentes
(lo puedes comprobar en las propiedades de capa capa), en efecto la extensión de la capa accflow es
más pequeña que la de la capa dem25
Nota
Eso significa que las capas no son iguales, y que no se puede multiplicar directamente sin
homogeneizar sus tamaños y extensiones mediante un algoritmo de remuestreo en una o ambas capas
para alinear los dos ráster y de esta forma que cada píxel de uno coincida con exactamente un píxel
del otro en el espacio.
Sin embargo, nosotros no hicimos nada. QGIS se hace cargo de esta situación y automáticamente
remuestreay alinea (align) las capas de entrada cuando es necesario. La extensión de salida es el
grado de recubrimiento mínimo calculado a partir de las capas de entrada, y el tamaño de celda mínimo
de sus tamaños de celda originales.
En este caso (y en la mayoría de los casos), se obtienen los resultados deseados, pero siempre se
debe tener presente todas las operaciones adicionales que se están produciendo, ya que podrían
afectar el resultado. En los casos en que este comportamiento no sea el deseado, se puede aplicar un
remuestreo manual por adelantado para alinear las capas. En capítulos posteriores, veremos más
sobre el comportamiento de los algoritmos utilizando múltiples capas ráster.
Vamos a terminar esta lección con otro ejercicio de aplicación de máscaras. Vamos a calcular la
pendiente en todas las zonas con una altitud entre los 1000 y 1500 metros.
En este caso, no tenemos una capa como una máscara, pero podemos crearla con la calculadora.
 Ejecuta la calculadora con dem25 como única capa de entrada y la siguiente fórmula (cuando
se utiliza una función no pongas un espacio antes del paréntesis de entrada porque quizás no
funcione): ifelse(abs(a - 1250) < 250, 1, 0/0)
Como se puede ver, se puede utilizar la calculadora no sólo para hacer las operaciones algebraicas
simples, sino también para funcionar cálculo más complejo que implica aplicar condicionales, como la
de arriba.
El resultado tiene un valor de 1 dentro de la gama que queremos trabajar, y sin datos en las celdas
fuera de ella.
23
El valor no-data proviene de la expresión 0/0 . Dado que es un valor indeterminado, SAGA agregará
un NaN (Not a Number), que en realidad es manejado como un valor sin datos ( no-data ). Con este
pequeño truco se puede establecer un valor sin datos sin necesidad de conocer el valor no-data en
SAGA.
 Ahora multiplica (con la calculadora ráster de SAGA) el ráster obtenido por la capa de
pendientes (slope.tif) que se incluye en el proyecto, y obtendrá el resultado deseado.
 Realiza una captura de pantalla de QGIS parecida a la imagen superior. Pega la imagen en la
plantilla de resultados
También se podría hacer todo en una sola operación con la calculadora. Lo dejamos como ejercicio
para el lector.
12.9.1 Tipo del ráster de salida

Hemos visto que la calculadora ráster de SAGA permite elegir el tipo de datos del ráster de salida, es
decir, el tipo de datos de los píxeles como float (decimales), byte, entero corto, entero largo, etc.
Por defecto, el tipo seleccionado es de tipo float donde cada píxel ocupa 4 bytes y permite almacenar
valores decimales, pero este tipo no siempre es adecuado u óptimo.
Tipo Valor mínimo Valor máximo Bits/Bytes por píxel

[0] bit 0 1 1 / (1/8)
[1] unsigned 1 byte integer 0 255 8/1
[2] signed 1 byte integer -128 127 8/1
[3] unsigned 2 byte integer 0 65535 16 / 2
[4] signed 2 byte integer -32768 32767 16 / 2
[5] unsigned 4 byte integer 0 4294967295 32 / 4
[6] signed 4 byte integer -2147483648 2147483647 32 / 4
[7] 4 byte floating point number -3.4E38 (7 dígitos) +3.4E38 (7 dígitos) 32 / 4
[8] 8 byte floating point number -1.7E308 (15 dígitos) +1.7E308 (15 dígitos) 64 / 8
24
Para esta práctica vamos a repetir la creación de la máscara sobre la capa dem25 que hemos hecho
antes aplicando la fórmula: ifelse(abs(a - 1250) < 250, 1, 0/0) pero esta vez vamos a
modificar el tipo de ráster de salida.
La fórmula solo devuelve valores de 0 y 1, por lo tanto en lugar de almacenar el resultado en un ráster
de tipo float [7], vamos a almacenarlo utilizando el tipo [1] y [3] que son enteros sin signo, de 1 y 2
bytes respectivamente.
 Repite el proceso tres veces, y da un nombre de la capa de salida (p. ej.: mascara_uint1byte,
mascara_uint2byte, mascara_float). Quizás debas de poner la extensión del formato ráster
por defecto que maneja SAGA que es .sdat al poner el nombre del fichero de salida.
Posteriormente comprueba el tamaño de los ficheros tiff creados en el disco duro (recuerda que si has
puesto solo el nombre del fichero y no la ruta entera, éste se habrá almacenado en la ruta configurada
en la carpeta de salida de la configuración de procesos) y también mira la información de la capa en
QGIS (propiedades de la capa / información) para rellenar la siguiente tabla (también podrías utilizar
gfdalinfo para obtener la información desde la caja de procesos buscando el algoritmo Información
del ráster):
Capa Tamaño en KB Tipo de datos (información de Valor utilizado para representar el

(fichero disco QGIS) valor de no-data (información de
duro .sdat) QGIS o gdalinfo)
mascara_uint1byte 241 KB Byte - Entero natural de 8 bits 0 (obtenido con gdalinfo)
mascara_uint2byte
mascara_float
 Rellena dicha tabla en la plantilla de resultados

Nota
Si los datos obtenidos de la calculadora son números enteros, entonces es adecuado modificar el tipo
de datos resultante, pero deberemos elegir un tipo de entero signed, es decir, con signo porque si
elegimos uno sin signo (unsigned) entonces el valor dedicado para almacenar no-data puede que SAGA
utilice el 0 y entonces tendremos problemas. Si quieres puedes probar a repetir el proceso pero con un
tipo [1] unsigned y ver qué pasa con el valor no-data.
25
Este tipo de comportamiento puede cambiar según el algoritmo utilizado, por ejemplo si utilizamos la
calculadora ráster de GDAL, entonces GDAL nos deja especificar el valor para no-data, lo cual es más
adecuado que lo que hace SAGA.
No hace falta que hagas este ejercicio, pero por curiosidad te mostramos la pantalla de la calculadora
ráster de GDAL, configurada para que el valor de no-data sea 255 y el tipo de salida Byte.
La forma de expresar la condición: ifelse(abs(a - 1250) < 250, 1, 0/0) en GDAL cambia
mucho, ya que utiliza la biblioteca numpy para definir las expresiones y se debe de utilizar su sintaxis:
where(absolute(A-1250)<250,1,255)
12.9.2 ¿Qué calculadora ráster utilizar?

Lo normal es que ahora mismo tengamos una gran duda, y es ¿qué calculadora ráster utilizar: la de
SAGA, GDAL o QGIS? A continuación la siguiente tabla muestra algunas características de dichas
calculadoras, y en función de nuestra experiencia y el objetivo del análisis utilizaremos una u otra:
GDAL SAGA QGIS

Facilidad de USO MEDIA-BAJA MEDIA ALTA
Opciones permitias ALTA MEDIA BAJA
Complejidad expresiones ALTA MEDIA-ALTA BAJA
Conversiones de formatos NO SI NO
 La calculadora de SAGA como hemos visto tiene más opciones (como el tipo de píxel de salida)
que la de QGIS, pero al igual que la de QGIS no controla el valor utilizado para no-data (como
sí lo hace GDAL).
26
 En cuanto a rapidez la de SAGA es claramente la más lenta y que más recursos consume al
tener que hacer conversiones a su formato nativo (sdat). La de GDAL es la más rápida.
 En cuanto a la expresión o fórmula a utilizar desde luego la más fácil e intuitiva es la de QGIS,
aunque la de SAGA y la de GDAL son más potentes, su gramática es más complicada. La de
GDAL aunque es más compleja que la de QGIS, tiene la ventaja de que es más potente que la
de SAGA y además utiliza la gramática estándar de la biblioteca numpy.
 Como resumen, para un usuario no experimentado lo normal es utilizar la calculadora ráster de
QGIS, y conforme se avanza un poco nos pasaríamos a la de GDAL. La de SAGA solo la
utilizaríamos si hay alguna expresión que no sabemos poner en la de GDAL.
RESUMEN
Recomendamos pues tras realizar los primeros experimentos y análisis espaciales, empezar a utilizar
la calculadora de GDAL y dejar únicamente la de SAGA par algún caso especial que nuestra
experiencia demuestre que la de GDAL no es apta para dicho cálculo.
12.10 Calculadora de campos

Resumen
En esta lección veremos cómo agregar nuevos atributos a una capa vectorial utilizando una expresión
matemática, por medio de la calculadora de campos (Field Calculator).
 Abre el proyecto de QGIS correspondiente a esta lección (example5) y verás que contiene una
capa vectorial census_boundaries .
Ya sabemos cómo utilizar la calculadora ráster para crear nuevas capas ráster utilizando expresiones
matemáticas.
Una herramienta similar está disponible para capas vectoriales, y genera una nueva capa con los
mismos atributos de la capa de entrada, además de uno adicional con el resultado de la expresión
introducida. El algoritmo se llama Calculadora de campos o Field Calculator (es un algoritmo nativo
de QGIS).
Ya la has utilizado bastante en módulos anteriores desde el botón , así que ahora la recordaremos
y también utilizaremos alguna expresión nueva.
 Accede a ella esta vez desde la caja e procesado buscando el algoritmo Calculadora de
campos o Field Calculator. Verás que es casi igual que la accedida desde , pero con una
gran diferencia y es que no modifica la capa actual sino que crea una nueva con el resultado.
 En primer lugar, vamos a calcular la densidad de población de raza blanca en cada polígono, lo
que representa un censo. Tenemos dos campos en la tabla atributos que podemos utilizar para
eso, es decir, WHITE y SHAPE_AREA. Sólo tenemos que dividirlos y multiplicar el resultado por
un millón (para tener la densidad por kilómetro cuadrado), por lo que podemos utilizar la siguiente
fórmula en el campo correspondiente:
("WHITE" / "SHAPE_AREA") * 1000000
 Rellena el diálogo de parámetros como la imagen siguiente y presiona Aceptar.

27
Esto generará una nueva capa que será copia de census_boundaries pero tendrá además un nuevo
campo denominado WHITE_DENS
Ahora vamos a calcular la relación entre los campos de hombres y mujeres ( MALES y FEMALES ) para
crear un nuevo campo que indique si la población masculina es numéricamente predominante sobre la
población femenina.
 Ahora que ya sabes utilizar la calculadora de campos, crea otro campo nuevo llamado
RATIO y aplica la siguiente fórmula: 1.0 * "MALES" / "FEMALES"
IMPORTANTE: Como ambos campos "MALES" y "FEMALES" son de tipo entero, el resultado se
trunca a un entero. Por esa razón multiplicamos por 1.0 el valor "MALES" , de esta forma el resultado
será decimal, ya que 1.0 es un número decimal.
Otra forma para convertir un valor a número flotante sería utilizar la función to_real que se
encuentra en la lista de funciones de la calculadora de campos en la sección de Conversiones.
to_real("MALES") / "FEMALES"
Nota
La diferencia entre utilizar el Field Calculator desde la caja de herramientas de procesado respecto al
botón de la tabla de atributos en el interfaz de QGIS, es que el algoritmo de la caja de procesado crea
siempre una nueva capa con el resultado final, mientras que la otra opción actualiza la tabla de atributos
de la capa.
Podemos incluso utilizar funciones condicionales para obtener un nuevo campo que indique qué valor
es el predominante.
CASE WHEN "MALES" > "FEMALES" THEN 'male' ELSE 'female' END
28
 Realiza una captura de pantalla de QGIS parecida a la imagen inferior, donde se vea una tabla de
atributos con los tres campos nuevos. Pega la imagen en la plantilla de resultados
Nota
El nombre de los campos se puede poner sin comillas en la calculadora de campos pero solo en el
caso de que no tengan ningún espacio en el nombre. Por seguridad al hacer clic en la lista de campos
de la calculadora de campos ésta los pondrá entre comillas siempre.
12.11 Definición de extensiones

Resumen
En esta lección veremos cómo definir extensiones, que son necesarias en algunos algoritmos,
especialmente los que utilizan capas ráster.
Algunos algoritmos requieren una medida para definir el área a ser cubierta por el análisis que realizan,
y por lo general para definir la extensión de la capa resultante.
Cuando se requiere una medida, se puede definir manualmente mediante la introducción de los cuatro
valores que lo definen ( min X, min Y, max X, max Y ), pero hay otras formas más prácticas y
más interesantes de hacerlo, lo vamos a ver en esta lección.
 Abre el proyecto de QGIS extent situado en processing / example6 .

29
 En primer lugar, vamos a abrir un algoritmo que requiere definir una extensión. Abre el algoritmo
de GDAL llamado Rasterizar (vectorial a ráster) o Rasterize (vector to raster) que convierte
una capa vectorial a ráster.
Configura el diálogo para rasterizar la capa vectorial con un tamaño de píxel de 10x10 metros,
como aparece a en la siguiente imagen:
Fíjate en los diferentes métodos para rellenar la extensión (casilla Extensión de salida):
- Usar la extensión del lienzo: al seleccionarlo usará la extensión actual de la vista/lienzo de

QGIS.
- Seleccionar extensión sobre el lienzo: este método nos permite seleccionar con el ratón un
rectángulo sobre el lienzo/vista de QGIS con la extensión.
- Usar la extensión de la capa: este método permite seleccionar una capa, que puede ser la
misma que la de entrada o cualquier otra, QGIS usará la extensión de dicha capa para definir
la extensión de la nueva capa creada.
 Selecciona como extensión de salida la misma que la capa watersheds.
 Ejecuta el algoritmo y comprueba que la extensión de la capa resultante es la misma que la capa
watersheds
12.12 Salida en HTML

Resumen
En esta lección aprenderemos como QGIS maneja salidas en formato HTML, que se utilizan para
producir salidas de texto y gráficos.
30
Todas las salidas que hemos producido hasta ahora en este módulo eran capas (ráster o vector). Sin
embargo, algunos algoritmos generan salidas en forma de texto y gráficos. Todas estas salidas se
crean mediante archivos HTML y se muestran en el Panel Visor de Resultados (o también en el
menú Procesos > Visor de Resultados).
Ya hemos utilizado en módulos anteriores algún algoritmo que devuelve una salida textual, como las
estadísticas básicas para campos… o Información del ráster (comando gdalinfo de GDAL). Ahora
vamos a ver una nueva funcionalidad que consiste en averiguar información pero de un fichero
vectorial (comando ogrinfo de GDAL) con el algoritmo Información del Vectorial o Vector
Information.
 Abre el proyecto html ( processing / example7 ) con los datos que se utilizarán en esta
lección y luego abre el algoritmo Información del Vectorial o Vector Information.
El algoritmo es bastante simple y sólo se deben seleccionar la capa a utilizar. La salida es de tipo HTML
y se puede introducir la ruta de un archivo o dejarlo en blanco para almacenarla en un archivo temporal.
En este caso, sin embargo, sólo se permiten las extensiones html and htm , de modo que no hay
manera de alterar el formato de salidoautilizando cualquier otra.
 Marca la opción Salida resumen solo , ya que sino sacará información de todas las features
que contiene la capa y Ejecuta el algoritmo seleccionando como entrada la única capa del
proyecto.
Al finalizar el algoritmo, aparecerá una nueva entrada en el Visor de resultados. Haz doble clic en
Información de la capa para acceder el informe html en el navegador.
El Visor de resultados mantiene accesibles de forma sencilla todos los resultados HTML generados
durante la sesión actual, de forma que puedan ser consultados cuando sea necesario. Al igual que
sucede con las capas, si la salida se ha guardado en un archivo temporal, ésta se eliminará al cerrar
QGIS. Si se ha guardado en un archivo no temporal, éste se mantendrá, pero no aparecerá en el Visor
de resultados la próxima vez que se inicie QGIS.
Algunos algoritmos generan los textos de forma que se pueden almacenar en variables. Ahora mismo
esto no tiene ninguna importancia, pero conforme nos movamos al modelador gráfico, comprobaremos
que nos permite utilizar dichos valores como entradas numéricas para otros algoritmos.
31
12.13 Primer ejemplo de análisis sencillo

Resumen
En esta lección vamos a realizar un análisis real aunque sencillo utilizando sólo la caja de herramientas
de procesos, así tendrás más familiaridad con los elementos del área de trabajo de procesamiento.
Ahora que todo está configurado y podemos usar algoritmos externos, tenemos una herramienta muy
poderosa para realizar análisis espacial, así que vamos a trabajar con un pequeño ejercicio con algunos
datos reales.
Vamos a utilizar el conjunto de datos que John Snow utilizó en 1854 en su trabajo pionero
(http://en.wikipedia.org/wiki/John_Snow_%28physician%29), y obtendremos algunos resultados
interesantes.
El análisis de este conjunto de datos es bastante obvio y no hay necesidad de técnicas SIG sofisticadas
para obtener buenos resultados y conclusiones, pero es una forma de mostrar cómo estos problemas
espaciales pueden ser analizados y resueltos mediante el uso de diferentes herramientas.
El conjunto de datos contiene archivos shape con muertes por cólera, ubicaciones de bombas de agua,
y un mapa renderizado de OSM en formato TIFF.
 Abre el proyecto de QGIS John_snow en processing / example8 de esta lección.
Lo primero que debe hacer es calcular el diagrama de Voronoi (también conocido como polígonos de
Thyessen) de la capa de bombas de agua, para obtener la zona de influencia de cada bomba.
 Ejecuta el algoritmo de Polígonos Voronoi o Voronoi Polygons y crea los polígonos de
Voronoi.
Bastante fácil, pero ya nos da cierta información interesante:

32
Claramente, muchos de los casos de cólera se encuentran dentro de uno de los polígonos
Para obtener un resultado más cuantitativo, podemos contar el número de muertes en cada polígono.
Dado que cada punto representa un edificio donde las muertes ocurrieron, y el número de muertes se
almacena en un atributo, no podemos contar solo los puntos.
 Necesitamos un recuento ponderado, por lo que utilizaremos la herramienta Contar puntos

en polígon (Count points in polygon). Ejecuta dicha herramienta con los siguientes
parámetros:
El nuevo campo se llamará DEATHS , y usamos el campo COUNT como campo de ponderación. La
tabla resultante refleja claramente que el número de muertes en el polígono correspondiente a la
primera bomba es mucho más grande que los otros.
33
Otra buena forma de visualizar la dependencia de cada punto de la capa Cholera_deaths con un punto
de la capa Pumps es dibujar una línea desde cada muerte a la bomba más cercana. Esto se puede
hacer con la herramienta Distancia al eje más próximo – Línea a eje (Distance to Nearest Hub –
line to hub) y el uso de la configuración que se muestra a continuación.
 Ejecuta dicha herramienta con los siguientes parámetros:
El resultado será algo como:

Aunque el número de líneas es mayor en el caso de
la bomba central, no hay que olvidar de que esto no
representa el número de muertes, sino el número de
lugares donde se encontraron casos de cólera.
Es un parámetro representativo, pero no está
considerando que algunos lugares podrían tener más
casos que otros.
 Una capa de densidad también nos dará una visión muy clara de lo que está sucediendo.
Podemos crearla con el algoritmo Mapa de calor (Estimación de densidad de núcleo) o
Heatmap (Kernel Density Estimation).
 Ejecuta la herramienta con los parámetros de la imagen siguientes (comprueba la imagen

siguiente).).
 Utiliza la capa Cholera_deaths, su campo COUNT como campo de peso, con un radio de
100 m, el tamaño del píxel (celda) de salida a 0.5 m, y la forma (shape) de kernel a
cuartic .
34
Se puede observar que hay una bomba claramente en el punto

de acceso donde se encuentra la máxima densidad de los casos
de muerte.
 Realiza una captura de pantalla de QGIS parecida a la

imagen inferior, donde se vean las distintas capas.
 Pega la imagen en la plantilla de resultados
35
12.14 Recortar y unir capas raster

Resumen
En esta lección vamos a ver otro ejemplo de preparación de datos espaciales, para seguir utilizando
los geoalgoritmos en los escenarios del mundo real.
Para esta lección, vamos a calcular una capa de pendientes para un área que rodea la ciudad (capa
vectorial con un único polígono).
El MDE base se divide en dos capas ráster que, en conjunto, cubren un área mucho mayor que cubre
totalmente la ciudad con la que queremos trabajar.
 Abre el proyecto correspondiente a esta lección (proyecto medforddem.qgs en processing >

example9 ), verás algo como esto:
Estas capas tienen dos problemas:
 Cubren un área que es demasiado grande para lo que queremos (que estamos interesados en
una región más pequeña alrededor del centro de la ciudad).
 Dicha área se encuentra en dos capas ráster diferentes (los límites de la ciudad caen en sólo
una, pero como se ha dicho, queremos alguna área adicional a su alrededor).
Ambos problemas son fácilmente solucionables con los geoalgoritmos apropiados.

En primer lugar, vamos a definir un rectángulo que defina el área que queremos. Para ello, crearemos
una capa que contenga un cuadro delimitador con los límites de la zona de la ciudad, y luego mediante
una operación de área de influencia (búfer) trataremos de ensanchar un poco esa área.
 Para calcular el cuadro de límite, podemos utilizar el algoritmo de QGIS Extraer extensión
de la capa (Extract layer extent). Ejecuta dicha herramienta con los siguientes parámetros:
Para extender el cuadro vamos a utilizar el algoritmo de QGIS Buffer con una distancia de 0.25
unidades. Luego calcularemos de nuevo el polígono de la extensión de la capa resultante.
36
 Ejecuta dicho proceso con una distancia de 0,25 grados y deja los demás parámetros por
defecto.
 Sobre la capa de salida del buffer vuelve a aplicar el algoritmo Extraer extensión de la capa.
Ejecuta para crear una capa rectangular con la nueva extensión.
La capa resultante la utilizaremos para cortar los ráster, hemos cambiado su nombre a Recorte.
Para realizar la operación de recorte, así como otras operaciones de análisis espacial como la
intersección, hace pocas versiones QGIS necesitaba que ambas capas tuvieran el mismo SRC nativo,
y si no era así era necesario reproyectar una de las capas al SRC de la otra.
Ahora, en algunas operaciones QGIS realiza esta reproyección de forma interna y transparente para el
usuario. La ventaja es que el usuario no se tiene que preocupar si las capas están en diferente SRC.
El inconveniente, es que quizás el usuario no es consciente que en ocasiones QGIS aplicará
reproyecciones, y si hablamos de capas ráster también podrá aplicar algún algoritmo de interpolación
(remuestreo o resampling) a la capa ráster, así como algún tipo de transformación entre datums no
deseada. Es decir, el usuario pierde el control de qué está haciendo el software con sus datos.
Por lo tanto, desde este curso RECOMENDAMOS SIEMPRE al realizar una operación de análisis entre
capas con diferente SRC, reproyectar de forma manual a un SRC común a ambas capas.
En este caso la capa de Recorte está en el SRC EPSG:4236 y la capa ráster dem1 o dem2, está
en el SRC EPSG:4269 .
Vamos a reproyectar la capa Recorte al SRC EPSG:4269 . Es mucho más fácil reproyectar 4 vértices
del polígono de recorte, que los millones de píxeles de dem1 para llevarla al SRC de la otra capa.
Nota
Si deseas asegúrate del SRC original de las capas dem1 y dem2, utiliza el proceso Información
Ráster que utilizará el comando gdalinfo y creará un html con el resultado de los metadatos del ráster.
 Ejecuta el algoritmo de QGIS Reproject Layer para realizar la reproyección. Fíjate en la

siguiente imagen si tienes alguna duda.
 Cambia el nombre de la capa de salida en QGIS a Recortefinal.
37
La capa resultado Recortefinal contiene el cuadro delimitador en el SRC EPSG:4269 de la capa

ráster que queremos obtener, podemos recortar ambas capas ráster, esto lo podemos realizar
utilizando el algoritmo de recorte con dos bibliotecas diferentes: GDAL o SAGA.
El algoritmo de SAGA es Clip raster with polygon mientras que el algoritmo de GDAL es Cortar
ráster por capa de máscara (Clip raster by mask layer).
Puedes comparar ambos algoritmos y ver su velocidad de ejecución, las opciones que permite, etc.
IMPORTANTE: En términos generales si la misma funcionalidad se encuentra con GDAL y SAGA, es
más aconsejable utilizar GDAL por razones de eficiencia, ya que es un biblioteca ampliamente usada
no solo en QGIS sino en otros muchos proyectos y está muy optimizada. Además QGIS está mejor
integrado con GDAL, ya que es la biblioteca que utiliza el mismo.
En las capturas hemos decidido guardar las salidas de forma permanente (no temporal) dándoles un
nombre simplemente porque de esta forma queda más claro los cuadros de diálogo (p. ej. Las rutas
utilizadas en el comando gdalwarp) aunque puedes dejar la salida como temporal sin ningún problema.
 Ejecuta la operación de recorte

mediante GDAL de las dos capas
según la siguiente imagen.
Fíjate como configuramos para el ráster de
salida el valor de no-data, su nombre y
marcamos las casillas para ajustar su
extensión y mantener la resolución de
entrada.
Fíjate como se puede cambiar el tipo de
datos del ráster de salida, así como cambiar
el formato de compresión de salida.
Anota cuantos segundos tarda en

ejecutarse porque lo vamos a comparar con
SAGA.
38
 Ejecuta de nuevo la misma operación pero con el ráster dem2 de entrada y crea el ráster
dem2rec.tif de salida
 Se propone al alumno realizar los mismos recortes pero utilizando el algoritmo de SAGA Clip
raster with polygon. Tras ello responde a las preguntas abajo planteadas en la plantilla de
resultados:
- ¿Qué algoritmo ha sido más rápido en su ejecución GDAL o SAGA?

- ¿Qué algoritmo contempla muchas más opciones el de GDAL o SAGA?
Una vez que las capas han sido recortadas, se pueden juntar utilizando el algoritmo de
GDAL Combinar (Merge) o el algoritmo de SAGA Mosaic Raster Layers . Elige uno de los dos
para unir los dos rásters.
Algoritmo de GDAL:
 Ejecuta dicha herramienta con los siguientes parámetros. Selecciona en Capas de entrada
las capas: dem1rec y dem2rec .
 Guarda la capa de salida como fulldem o si quieres déjala como temporal. Deja el resto de
parámetros por defecto.
39
Algoritmo de SAGA:
En este caso el algoritmo de SAGA dispone de más opciones que el de GDAL como elegir el
comportamiento en las zonas comunes de los ráster a unir.
 Ejecuta el algoritmo Mosaic Raster Layers con los siguientes parámetros. Selecciona en
Input Grids , las dos capas en input Grids: dem1rec y dem2rec . Rellena el resto de
parámetros como la imagen inferior.
 Guarda la capa de salida como fulldem o si quieres déjala como temporal.
 Para elegir el parámetro Cellsize consultaremos el tamaño de celda de las capas dem1 o
dem2. Puedes verlo en propiedades de la capa, en la pestaña información o ejecutar el
proceso de Información Ráster.
Para Blending Distance multiplicaremos el tamaño de celda de la capa

dem1rec_cellsize * 25 :
Nota
Puedes ahorrar tiempo fusionando primero y luego recortando las capas, y evitarás así llamar al
algoritmo de recorte dos veces. Sin embargo, si hay varias capas que fusionar y tienen un tamaño
bastante grande, el resultado final contendrá una capa muy grande que puede ser difícil de procesar.
En este ejemplo hemos llamado al algoritmo de recorte varias veces, lo que podría llevar mucho tiempo
al tener que repetir la configuración del proceso si tuviéramos muchas capas que recortar, pero no te
preocupes, pronto veremos que hay algunas herramientas adicionales para automatizar la operación
de repetir un algoritmo. En este ejemplo, sólo tenemos dos capas, por lo que no debemos preocuparnos
por eso ahora.
40
12.14.1 Mapa de pendientes

Ahora vamos a calcular una capa de pendientes a partir de la capa fulldem, pero tenemos un problema
y es que el valor de elevación está en metros pero las coordenadas ( EPSG:4269 ) están en grados.
Para que el cálculo de pendientes, direcciones, sombreado, etc. sea correcto la capa fulldem debería
tener las coordenadas planimétricas X e Y en metros y para lograr esto hay que reproyectar la capa
fulldem a un CRS proyectado antes de calcular la pendiente.
Vamos a reproyectar la capa fulldem al SRC EPSG:3857 (Esférica de Mercator) y de esta manera
calcular la pendiente correctamente.
Para reproyectar capas en formato ráster, tenemos el algoritmo de GDAL que se llama Combar
(reproyectar) o en inglés Wrap (reproject) y que utiliza el comando warp de GDAL.
 Ejecuta dicha herramienta con los siguientes parámetros: seleccionamos las capa de
entrada: fulldem y el SRC destino a EPSG:3857
 Guarda la capa de salida como fulldem3857 o si quieres déjala como temporal.
Ahora ya podemos calcular la capa de pendientes a partir de fulldem3857. Para ello, podemos
utilizar el algoritmo pendiente (slope) de GDAL o el Slope, aspect, curvature de SAGA.
 Por ejemplo ejecuta el algoritmo con GDAL con los siguientes parámetros:
41
El resultado final será:
 Realiza una captura de pantalla de QGIS parecida a la imagen superior, donde se vea la capa
final de pendientes. Pega la imagen en la plantilla de resultados
Puedes probar a realizar las pendientes de la capa sin reproyectar fulldem y comparar el resultado
de los valores obtenidos en las celdas (que será erróneos).
42
12.15 Análisis Hidrológico

Resumen
En esta lección vamos a realizar algunos análisis hidrológicos. Este análisis se utilizará en siguientes
lecciones, ya que constituye un buen ejemplo de un flujo de trabajo de análisis espacial, y vamos a
utilizarlo para demostrar algunas características avanzadas.
A partir de un MDE, vamos a extraer una red de canales, delimitar las cuencas hidrográficas y calcular
algunas estadísticas.
 Carga el proyecto con los datos de la lección (proyecto hydro.qgs en processing >
example10 ), que sólo contiene un MDE
 Ejecuta el algoritmo Catchment area de SAGA con los siguientes parámetros:
La imagen de abajo muestra la zona de captación (tras ajustar el histograma con ) calculada
aunque no se visualiza muy bien. Para saber por qué, se puede echar un vistazo al histograma y verás
que los valores no se distribuyen de manera uniforme (hay algunas celdas con muy alto valor, los
correspondientes a la red de canales).
Recuerda como hicimos antes que con fines de visualización calculamos el algoritmo de dicha capa
para verla mejor, así que si quieres puedes probarlo por ti mismo.
La zona de captación (también conocida como acumulación de flujo), se puede utilizar para establecer
un umbral para la iniciación de canal. Esto se puede hacer utilizando el algoritmo Channel network.
43
 Ejecuta el algoritmo Catchment area de SAGA con los siguientes parámetros:
Así es como hay que configurarlo (nótese el umbral

(threshold) de Iniciación es mayor que ( Greater
than ) 10.000.000 ).
EL algoritmo creará tres capas:

- Una en formato vectorial lineal con el canal
- Otra en formato ráster con el canal (esta es la
que necesitaremos para el siguiente
algoritmo).
- Otra en formato ráster con la dirección del canal.
De las tres solo vamos a necesitar la vectorial, así que

las demás las puedes quitar de tu proyecto de QGIS.
La capa del canal de la red quedará como sigue:

Si aumentas el valor del umbral de iniciación, obtendrás una red de canales más escasa. Si lo
disminuyes, se obtendrá una red de canales más densa.
Ahora, vamos a utilizar el algoritmo Watersheds Basins para delinear las subcuencas
correspondientes a esa red de canales, utilizando como puntos de salida de todas las uniones
(bifurcaciones) en ella.
44
 Ejecuta el algoritmo Watersheds Basins de SAGA con los siguientes parámetros (puedes
dejar si quieres la salida en temporal):
Obtendremos una capa ráster que contiene las subcuencas, que vectorizaremos después:
Ahora podemos vectorizar el resultado utilizando los algoritmos Poligonizar (ráster a vectorial) o en
inglés Polygonize (raster to vector) de GDAL o Vectorising grid clases de SAGA.
 Ejecuta el algoritmo Poligonizar (ráster a vectorial) de GDAL con los parámetros (deja
si quieres la capa de salida temporal):
45
Como ejemplo, también te ponemos el diálogo del correspondiente algoritmo (Vectorise raster
classes ) en SAGA.
En la imagen, la capa de salida (simbolizada por el campo DN) está renombrada a BasinsVector :
Ahora vamos a probar a obtener estadísticas del MDE de alguna de las áreas de las subcuencas
(tenemos 7 áreas). Esta tarea se puede realizar de muchas maneras como:
1) Recortando el ráster dem25 por alguno de los polígonos de la capa BasinsVector y

posteriormente calculando estadísticas básicas de ese ráster recortado. Los algoritmos a
utilizar serían: Seleccionar primero un polígono en QGIS de forma manual, utilizar Cortar
ráster por capa de máscara (Clip raster by mask layer) de GDAL, o Clip raster with
Polygon de SAGA, y por último utilizar Estadísticas de capa ráster (Raster Layer statistics)
de QGIS.
2) Utilizando el algoritmo de QGIS Estadísticas de zona (Zonal statistics), o el algoritmo de

SAGA Raster statistics for polygons. Los cuales tienen la ventaja de obtener las estadísticas
de todas las subcuencas en un solo paso y sin necesidad de recortar el ráster.
3) Por último, se puede realizar lo mismo que en la solución 2 pero en lugar de utilizar como
capa de zonas una capa vectorial (BasinsVector) se puede utilizar directamente la capa ráster
(Basins).
Para ello, debemos utilizar el algoritmo de QGIS Raster layer Zonal Statistics o el de SAGA
Zonal raster statistics que trabajan íntegramente con datos ráster.
La ventaja es que no es necesario vectorizar previamente la capa Basins pero como desventaja
los resultados obtenidos son una tabla alfanumérica, lo cual es menos útil que la capa vectorial
de las zonas con sus estadísticas asociadas.
46
De estas tres formas vamos a ejecutar a continuación el método 2 (con QGIS) por ser el más sencillo
y rápido. Dejamos también indicado la solución con el método 3, porque aunque es más compleja
incluye una operación de unión de tablas de atributos lo cual si el alumno no lo ha realizado antes
puedes ser interesante.
 Ejecuta el algoritmo Estadísticas de zona de QGIS.
Hemos cambiado el prefijo DN_ de los campos que serán añadidos a la tabla de atributos de
la capa BasinsVector.
Selecciona también algunos estadísticos (cada uno será un campo nuevo de BasinsVector),
como por ejemplo: Número, Suma, Media, Min, Max y Varianza .
Este algoritmo no crea una capa nueva, sino que añade a la capa de zonas BasinsVector los atributos
con las estadísticas calculadas de la capa dem25 para cada polígono.
 Realiza una captura de pantalla de QGIS parecida a la imagen superior, donde se vea la tabla de
atributos con las estadísticas de las subcuencas. Pega la imagen en la plantilla de resultados
47
Por último se ponen los pasos para realizar el ejercicio siguiendo la solución 3 con QGIS con el
algoritmo Raster layer Zonal Statistics.
- En Capa de entrada, elegiremos la capa de datos para las estadísticas, es decir, la capa dem25
- En Capa de zonas / Zones layer elegiremos la capa zonal, es decir, la capa ráster Basins
El algoritmo creará una tabla alfanumérica (es decir, sin ninguna geometría asociada, ya que proviene
de análisis ráster) Estadísticas con estadísticas similares a las obtenidas en el apartado anterior:
La tabla recién creada Estadísticas tiene un campo zone que coincide con el número de subcuenca
que también aparece como el campo DN de la capa de atributos de la capa vectorial de las subcuencas
BasinsVector.
Como vemos, no ha hecho falta utilizar la capa vectorial BasinsVector, aunque si dispusiéramos de
ella siempre podríamos PEGARLE las estadísticas mediante una unión por el campo común ( zone
de Estadísticas con DN de BasinsVector), que es lo que vamos a realizar ahora:
Esto lo podemos hacer con el algoritmo Join attributes by field value o Unir atributos por valor de
campo de QGIS.
Para realizar una unión de dos tablas por un campo de atributos, estos demás de representar los
mismos valores, generalmente tienen que ser del mismo tipo. Quizás puedas tener aquí un pequeño
problema y es que en la tabla de la imagen superior vemos que el campo zone es de tipo decimal,
pero el campo DN de la tabla BasinsVector es de tipo entero.
48
Si al realizar la unión ves que no ha funcionado (como nos ha pasado a nosotros), utiliza la calculadora
de campos sobre la capa Estadísticas para añadir un nuevo campo de nombre ZoneInt de tipo
entero y copia en el los valores del campo Zone
Como último paso realizamos la unión de las dos tablas por dicho campo común. Se creará una nueva
capa.
Se creará una nueva capa con la unión de BasinsVector y Estadísticas:

49
12.16 Comenzando con el modelador gráfico

Resumen
En esta lección vamos a utilizar el modelador gráfico, un componente muy potente que podemos utilizar
para definir un flujo de trabajo y gestión de una cadena de algoritmos.
Una sesión de trabajo normal con las herramientas de procesamiento incluye la ejecución de varios
algoritmos para obtener un resultado, y las salidas de algunos de esos algoritmos se utilizan como
entrada para algunos de los otros.
Utilizando el modelador gráfico, este flujo de trabajo se puede materializar en un modelo, que
desarrollará todos los algoritmos necesarios de una sola vez, lo que simplifica todo el proceso y facilita
la automatización del proceso.
Para comenzar esta lección, vamos a calcular un parámetro denominado Índice Topográfico de
Humedad. El algoritmo que lo calcula que se llama Topographic wetness index (TWI) de SAGA.
 Carga el proyecto con los datos de la lección (proyecto modeler_twi.qgs en processing >
example11 ), que contiene solo una capa de MDE
Este algoritmo necesita dos entradas obligatorias: Una capa de pendientes (con valores en radianes) y
otra de área de captación (catchment area).
Los datos para esta lección contiene sólo un MDE, por lo que no tiene ninguna de las capas de entrada
requeridas. Sin embargo, sabemos cómo calcular ambas desde el MDE, como ya hemos visto
anteriormente. Vamos a calcular esas capas y luego a usarlas para el algoritmo TWI.
Aquí están los cuadros de diálogo de los parámetros que se deben utilizar para el cálculo de las 2 capas
intermedias. Para el cálculo de la pendiente utilizaremos también SAGA aunque podríamos haber
utilizado GDAL.
 Ejecuta los dos algoritmos con los siguientes parámetros:
Catchment Area con SAGA Slope, aspect, curvature con SAGA

Desmarca todas las salidas menos la primera de Slope.
Selecciona radians.
50
Los parámetros para el algoritmo TWI quedarán (Topographic wetness index de SAGA):
Y el resultado final (puedes utilizar el estilo twi.qml en la carpeta example11):
Lo que vamos a tratar de hacer ahora es crear un algoritmo que calcule el TWI de un MDE en un solo
paso.
Eso ahorrará trabajo en caso de que más adelante tengamos que calcular una capa TWI de otro DEM,
ya que vamos a necesitar sólo un solo paso para hacerlo en lugar de los 3 de más arriba.
Todos los procesos que necesitamos se encuentran en la caja de herramientas, así que lo que tenemos
que hacer es definir el flujo de trabajo para modelarlos. Aquí es donde el modelador gráfico entra en
juego.
 Abre el modelador seleccionando su entrada de menú en el menú de procesamiento (menú

Procesos > Modelador gráfico).
Necesitamos dos cosas para crear el modelo: configurar las capas de entrada y definir el algoritmo que
se necesita. Ambas se logran añadiendo elementos desde el panel de la izquierda (pestañas de
entradas y algoritmos) a la ventana del modelador de la derecha.
 Haz doble clic en la entrada de Raster layer para definir la entrada de nuestro algoritmo. Le
llamaremos DEM , ya que esperamos que contenga la capa ráster del MDE:
51
 Presiona aceptar y la entrada aparecerá en la ventana del modelador.
Ahora vamos a pasar a la pestaña de algoritmos. El primer algoritmo vamos a ejecutar es Slope,
aspect, curvature de SAGA.
 Busca este algoritmo en la pestaña Algoritmos dentro de la ventana del Modelador de

procesado , haz doble clic en él y verás el diálogo que se muestra a continuación:
Este diálogo es muy similar a la que encontrábamos cuando se ejecutaba el algoritmo de la caja de
herramientas, pero los elementos (capas) que se pueden utilizar como valores de los parámetros NO
se toman del proyecto de QGIS actual, sino del propio modelo. Además, verás que no existen las
típicas opciones de “Abrir el archivo de salida después de ejecutar el algoritmo”.
Eso significa que, en este caso, no vamos a tener todas las capas ráster de nuestro proyecto para
definir el valor de Elevation, sino sólo las capas que se corresponden con las entradas que se definen
en nuestro modelo. Como hemos añadido una sola entrada ráster llamada DEM , ésta será la que
veamos en la lista correspondiente al parámetro de elevación.
52
La salida generada por un algoritmo se maneja un poco diferente cuando el algoritmo se utiliza como
parte de un modelo. En lugar de seleccionar la ruta de archivo en el que desea guardar cada salida,
sólo hay que especificar si la salida es un resultado intermedio (temporal que desaparecerá tras ejecutar
el modelo) o quedará grabado en el disco tras su ejecución.
En este caso, todas las capas producidas por este algoritmo son intermedias. Sólo usaremos una de
ellas (la capa de pendiente), pero no queremos que la mantenga, ya que sólo la necesitamos para
calcular la capa TWI, que es el resultado final que se quiere obtener.
Cuando las capas no son un resultado final, sólo hay que dejar el campo correspondiente en blanco:
De lo contrario, tendrás que introducir un nombre que se utilizará para identificar la capa en el diálogo
de parámetros que se mostrará cuando se ejecuta el modelo posterior.
 Tras cambiar las unidades a radianes y seleccionar la entrada DEM, presiona Aceptar. El
modelador presentará el siguiente aspecto:
Fíjate como si haces clic en el botón + de la salida (out) del algoritmo aparecen todas las capas
intermedias que genera.
 Añade de la misma forma el algoritmo Catchment Area de SAGA. Utilizaremos el parámetro

DEM en el Elevation, deja la salida sin rellenar, ya que no hay resultados finales tampoco.
53
 Como último paso añade el algoritmo Topographic wetness index de SAGA con los
siguientes parámetros:
En este caso, no vamos a usar el DEM como entrada,
sino las capas de pendiente y área de captación que
se calculan con los algoritmos que hemos añadido
anteriormente.
A medida que se agregan nuevos algoritmos, las
salidas que producen están disponibles para
cualquier otro algoritmo del modelo. El vincular
estas entradas y salidas entre los algoritmos crea el
flujo de trabajo.
En este caso, la capa de TWI salida es una capa

final, así que tenemos que indicarlo en el campo
Topographic Wetness Index.
.
Ahora nuestro modelo está terminado y que debe tener este aspecto:
 Introduce un nombre (p. ej.: TWI from DEM ) y un nombre de grupo (p. ej: My Models )
en la parte superior de la ventana del modelo, y luego haz clic en el botón de guardar.
El modelo se puede guardar en cualquier carpeta que se quiera y abrirlo más adelante, pero si se
guarda en la carpeta de los modelos por defecto de QGIS (que es la carpeta que aparece cuando por
defecto con el diálogo de archivo de salvar), entonces este modelo también estará disponible en la caja
de herramientas de QGIS.
 Graba el modelo con cualquier nombre, p. ej.: twifromdem .

54
El directorio por defecto de los modelos de QGIS dependerá del SO que estés utilizando, pero en
general se almacenará en la carpeta del usuario dentro de una subcarpeta. En MS Windows la
subcarpeta dentro de la carpeta de usuario es:
…\ AppData\Roaming\QGIS\QGIS3\profiles\default\processing\models
 Ahora cierra el diálogo del modelador y vete a la caja de herramientas de procesado y busca
tu nuevo algoritmo.
Puedes utilizar al algoritmo como otro algoritmo cualquiera. Si quieres cambiar algún parámetro puedes
volver al modelador, abrir el algoritmo de nuevo, y hacer clic derecho sobre cualquier algoritmo para
cambiar algún valor.
Eso sí, no olvides grabar el modelo de nuevo.

55
12.17 Modelos más complejos

Nota
En esta lección vamos a trabajar con un modelo más complejo en el modelador gráfico.
El primer modelo que hemos creado en el capítulo anterior era muy simple, con una sola entrada y 3
algoritmos. Los modelos más complejos se pueden crear, con diferentes tipos de entradas y contienen
más pasos. Para este capítulo trabajaremos con un modelo que crea una capa vectorial con las cuencas
hidrográficas, en base a un DEM y un valor de umbral. Será muy útil para el cálculo de varias capas
vectoriales correspondientes a diferentes umbrales, sin tener que repetir cada paso sencillo cada vez.
Esta lección no contiene instrucciones sobre cómo crear tu modelo. Ya conoces los pasos necesarios
(los vimos en una lección anterior, apartado 12.15) y ya has visto las ideas básicas sobre el modelador,
por lo que debes ser capaz de hacerlo por ti mismo. Dedica unos minutos para tratar de crear el modelo,
y no te preocupes por cometer errores.
 Carga el proyecto con los datos de la lección (proyecto modeler_hydro.qgs en processing

> example12 ), que sólo contiene una capa de MDE
 Realiza el modelo de procesado según la imagen inferior y teniendo en cuenta lo siguiente:

 Recuerde: agregar primero las entradas y después agregar los algoritmos que los usan para
crear el flujo de trabajo.
 El initiation Threshold para el algoritmo de Channel network es de mayor ( greater

than ) de 10000000 (10 millones). Los demás parámetros son simplemente las capas
utilizadas dejando los demás parámetros por defecto.
 Todos los algoritmos son de SAGA, menos Poligonizar (ráster a vectorial) o Polygonize
(raster to vector) que es de GDAL.
 El modelo se llamará Watershed from DEM dentro del grupo My Models .
 Guarda el modelo en el directorio por defecto de QGIS para los modelos, con el nombre
watershedfromdem , de esta forma aparecerá en la caja de procesos.
 Prueba a ejecutar el modelo con la capa DEM, obtendrás una capa vectorial igual que el apartado
12.15 pero sin tanto esfuerzo!. Ten paciencia, SAGA es bastante lento, tardará varios minutos.
56
Este modelo contiene todos los pasos necesarios para completar los cálculos, sin embargo solo tiene
una entrada: el DEM . Eso significa que el umbral initiation Threshold para la definición del
canal utiliza un valor fijo, lo que hace el modelo no sea tan útil como podría ser. Eso no es un problema,
ya que podemos editar el modelo y eso es exactamente lo que vamos a hacer:
 Edita el modelo anterior y Cambia también el nombre del modelo a: Watershed from DEM
with threshold
 Guárdalo también con otro nombre (p. ej.: watershedfromdemwiththreshold ) para así
poder editarlo y no borrar el anterior por si tenemos algún problema.
En primer lugar, vamos a añadir una entrada numérica. Será una entrada numérica que el usuario de
nuestro algoritmo utilizará como parámetro de entrada.
 Haz clic en el panel de Parámetros > Entradas, en el item Número, y verás el diálogo
correspondiente. Rellena con los siguientes valores. Valor por defecto (omisión) igual a
1000000 (1 millón). Presiona Aceptar.
 Para utilizar dicho parámetro, edita el algoritmo Channel network de tu modelo y cambia el valor
del parámetro Initiation Threshold de 10.000.000 a Threshold for channel
definition .
El modelo final tendrá el siguiente aspecto:

57
 Realiza una captura de pantalla del modelador de QGIS donde se vea este último modelo creado.
Pega la imagen en la plantilla de resultados
Ahora tendremos dos modelos, uno sin parámetro de umbral y este último con parámetro de umbral:
 Ejecuta varias veces tu modelo Watershed from DEM with threshold con la capa dem25
y con diferentes umbrales como 1 millón, 2 millones, 3 millones, etc.
 Realiza varias capturas de pantalla de las subcuencas obtenidas con diferentes umbrales como la
imagen inferior. Pega la imagen en la plantilla de resultados
100 000 500 000 1 000 000
2 000 000 3 000 000 5 000 000

58
12.18 Cálculos numéricos en el modelador

Resumen
En esta lección veremos cómo utilizar salidas numéricas en el modelador
Para esta lección, vamos a modificar el modelo hidrológico que creamos en el capítulo anterior, para
automatizar el cálculo de un valor de umbral válido y no tener que pedir al usuario que introduzca uno.
Este valor umbral lo extraeremos de la capa de la zona de captación (Catchment Area), a partir de un
análisis estadístico simple.
 Edita el modelo anterior y Cambia también el nombre del modelo a: Watershed from DEM
with automatic threshold
 Guárdalo con otro nombre (p. ej.: watershedfromdemwithautomaticthreshold ) para

así poder editarlo y no borrar el anterior por si tenemos algún problema.
A partir del modelo antes mencionado, vamos a hacer las siguientes modificaciones:
Primero, vamos a calcular las estadísticas de la capa de acumulación de flujo o área de captación
(Catchment Area) con el algoritmo Estadísticas de capa ráster (Raster layer statistics) de QGIS
 Añade el siguiente algoritmo a tu modelo:
Esto generará un conjunto de valores estadísticos que ahora estarán disponibles para todos los campos
numéricos en otros algoritmos.
Edita el algoritmo Channel network para modificarlo, como hicimos en la última lección. Ahora verás
que tienes otras opciones (elige Usar la salida del algoritmo ) aparte de la entrada numérica
en la casilla de Initiation Threshold como Valor mínimo del algoritmo ‘Raster layer statistics’, etc.
59
Sin embargo, ninguno de estos valores es adecuado para ser utilizado como un umbral válido, ya que
se crearían redes de canales no muy realistas. Podemos, en cambio, obtener algún parámetro nuevo
basado en ellos, para obtener un mejor resultado. Por ejemplo, podemos utilizar la media más 2 veces
la desviación estándar (µ + 2σ).
Antes de aplicar esta expresión vamos a cambiar el nombre al algoritmo Estadísticas de capa ráster
a un nombre más sencillo como rasterstatistics. Siempre es mejor que no tenga acentos ni espacios
para usarlo en el cálculo de la expresión.
 Para ello, edita el algoritmo Estadísticas de capa ráster y modifica su descripción a

rasterstatistics
 Edita el algoritmo Channel network y en Initiation Threshold selecciona Valor

precalculado .
Haz clic en el editor de expresiones en el botón de la izquierda y crea la siguiente

expresión:
 Elimina la entrada Threshold for channel definition , ya que ahora el algoritmo

calculará su propio umbral y este parámetro de entrada está ahora desconectado en el modelo.
 Haz clic en Aceptar y en Aceptar otra vez en el diálogo del algoritmo.
 Ejecuta el algoritmo.
60
12.19 Un modelo dentro de otro

Resumen
En esta lección vamos a ver cómo utilizar un modelo dentro de un modelo más grande.
Ya hemos creado algunos modelos, y en esta lección vamos a ver cómo podemos combinarlos en único
modelo más grande. Un modelo se comporta como cualquier otro algoritmo, lo que significa que puedes
agregar un modelo que ya has creado como parte de otro.
En este caso, vamos a ampliar nuestro modelo hidrológico, añadiendo el valor medio TWI en cada
una de las cuencas que genera como resultado. Para hacer eso, tenemos que calcular el TWI y calcular
las estadísticas. Como ya hemos creado un modelo para calcular TWI de un DEM (modelo al que
anteriormente llamamos TWI from DEM ), es una buena idea volver a usar ese.
Vamos a empezar con el modelo se utilizó como punto de partida de la última lección, es decir,
Watershed from DEM with threshold.
 Edita el modelo Watershed from DEM with threshold y Cambia su nombre a: TWI
by Watershed
 Guárdalo con otro nombre (p. ej.: twibywatershed ) para así poder editarlo y no borrar el
anterior por si tenemos algún problema.
 Añade en primer lugar el algoritmo TWI from DEM al modelo TWI by Watershed. Para
que esté disponible deberíamos haber guardado dicho modelo en la carpeta de los modelos
por defecto de QGIS como se ha comentado anteriormente.
61
Añádelo al modelo actual y utiliza el DEM como su

entrada. La salida es temporal, ya que sólo queremos la
capa TWI para calcular las estadísticas.
La única salida del modelo que estamos creando ( TWI

by Watershed ) seguirá siendo la capa vectorial con
las cuencas hidrográficas.
Ahora tenemos una capa TWI que podemos utilizar junto con la capa de las cuencas hidrográficas de
vectores, para generar una nueva que contenga los valores de la TWI correspondientes a cada cuenca.
Este cálculo se realiza utilizando el algoritmo Estadísticas de Zona (Zonal Statistics) de QGIS que
ya hemos utilizado antes, aunque tenemos un problema, y es que dicho algoritmo no crea un nuevo
resultado (nueva capa) sino que agrega campos a la capa vectorizada. Preferimos en este caso un
algoritmo que cree una nueva capa así que vamos a utilizar el algoritmo Raster statistics for polygons
de SAGA.
 Añade el algoritmo Raster statistics for polygons de SAGA a tu modelo y rellénalo con las
capas mencionadas anteriormente como entrada.
En el resultado de salida escribe TWI Statistics .
En Grids selecciona ‘ TWI’ from algorithm TWI from DEM . En Polygons la capa de
zonas.
Deja todas las estadísticas por defecto
En Statistics escribe TWI Statistics que será el resultado final no temporal.
Por último nos quedará eliminar el resultado final del algoritmo Polygonize (raster to polygon),
resultado que fue originalmente nuestro resultado final, pero ahora sólo se quiere como un resultado
intermedio.
62
 Para eliminarlo, simplemente borra la caja correspondiente al resultado final watersheds.
Alternativamente para eliminarlo también puedes editar el algoritmo Poligonizar… y borrar el

nombre de la salida. Eso hará que sea una salida temporal, ya que es por defecto.
Como puede ver, el uso de un modelo en otro modelo es nada especial, y se puede añadir al igual que
se agrega otro algoritmo, siempre y cuando el modelo se guarde en la carpeta de modelos y esté
disponible en la caja de herramientas.
 Guarda el algoritmo y pruébalo con la capa dem25 de los ejercicios anteriores (utiliza un umbral
de 5 millones):
 Realiza una de pantalla donde se vea la nueva capa creada y su tabla de atributos. Pega la imagen
en la plantilla de resultados
63
12.20 La interpolación
Resumen
En este capítulo se muestra cómo interpolar datos de puntos, y se mostrará otro ejemplo real de la
realización de análisis espacial
En esta lección, vamos a interpolar datos de puntos (datos discretos) para obtener una capa ráster
(datos continuos). Antes de hacerlo, vamos a tener preparar un poco los datos, y después de la
interpolación vamos a añadir algo de procesamiento adicional para modificar la capa resultante, así que
vamos a tener un flujo de análisis completo.
 Carga el proyecto con los datos de la lección (proyecto interpolation.qgs en processing >
example13 ), que contiene dos capas vectoriales, una de puntos y otra de polígonos con la
extensión de la zona, ambas en el SRC EPSG:32755
Los datos se corresponden con datos de cosecha, como el producido por una cosechadora moderna,
y vamos a utilizarlo para conseguir una capa ráster de productividad de los cultivos.
No vamos a realizar ningún análisis espacial con esta capa, solo la vamos a utilizar como una capa de
fondo para identificar fácilmente las áreas más productivas y también aquellas áreas en las que la
productividad se puede mejorar.
Lo primero que debe hacer es limpiar la capa, ya que contiene puntos redundantes. Estos son causados
por el movimiento de la cosechadora, en lugares en los que tiene que hacer un giro o se cambia su
velocidad por alguna razón.
El algoritmo Points filter de SAGA será útil para esto. Lo vamos a utilizar dos veces para eliminar los
puntos que se pueden considerar valores extremos tanto en la parte alto como baja de la distribución.
 Primero, ejecuta el algoritmo con los valores de parámetros de la imagen inferior izquierda.
 Ejecuta de nuevo el algoritmo (parámetros de la imagen inferior derecha). Nótese que no

estamos utilizando la capa original como entrada, sino la capa de salida de la primera
ejecución.
La capa de filtro final, con un conjunto reducido de puntos, debe ser similar a la original, pero contiene
un menor número de puntos. Puedes comprobarlo mediante la comparación de sus tablas de atributos.
La primera tabla filtrada contiene sobre 19700 puntos y la tabla final filtrada sobre 18100 puntos. La
tabla original sorghum contiene 22913 puntos.
64
 Tendrás dos capas con el mismo nombre Filtered

Points. Elimina la primera del proyecto de QGIS
para evitar confusiones y quédate con la que menos
puntos tenga.
 Ahora vamos a rasterizar la capa. Ejecuta para ello
el algoritmo Rasterize de SAGA con los parámetros
de la imagen:
La capa Filtered Points se refiere a la resultante

del segundo filtro.
65
La capa ráster resultante se parece a esto:
La capa resultante es una capa de tipo ráster, pero faltan datos en algunas celdas, ya que
sólo tienen valores válidos aquellas celdas que contenían un punto de la capa vectorial, y un
valor sin datos en todas los demás. Para llenar estos valores sin datos, podemos utilizar el
algoritmo Close gaps de SAGA.
 Ejecuta el algoritmo Close gaps de SAGA según la imagen inferior:
Obtendrás una capa similar a la siguiente:

66
Para restringir el área cubierta por los datos sólo a la región en la que se midió el rendimiento del cultivo,
vamos a recortar la capa ráster Result (tu capa podría llamarse diferente) con la capa de límites
proporcionada limits utilizando el algoritmo Clip raster with polygon de SAGA.
 Ejecuta dicho algoritmo con los siguientes

parámetros:
Después de recortar la capa, también podríamos

aplicar un filtro de suavizamiento, ya que la capa
solo la vamos a utilizar como fondo con fines de
visualización. Para ello, utilizamos el algoritmo
Gaussian filter de SAGA sobre la capa
recortada.
 Ejecuta dicho algoritmo con los siguientes

parámetros:
El resultado final aplicando una rampa de color para su visualización será algo como:
 Realiza una de pantalla similar a la imagen superior. Pega la imagen en la plantilla de resultados
67
12.21 Más interpolación

Resumen
En este capítulo se muestra otro caso práctico donde se utilizan algoritmos de interpolación.
La interpolación es una técnica común, y puede usarse para demostrar varias técnicas que se pueden
aplicar utilizando el marco de procesamiento de QGIS. Esta lección utiliza algunos algoritmos de
interpolación que ya fueron introducidos, pero con un enfoque diferente.
Los datos para esta lección contienen también una capa de puntos, en este caso con datos de
elevación.
 Carga el proyecto con los datos de la lección (proyecto interpolation_cross.qgs en
processing > example14 ).
En primer lugar, tenemos que rasterizar la capa de puntos y llenar rellenar las celdas que no tengan
datos.
Antes vamos a extraer un 10% de los puntos de la capa que utilizaremos para realizar alguna
comprobación tras la interpolación. De esta forma, vamos a realizar la interpolación con solo el 90% de
los puntos originales.
Para ello, podríamos utilizar el algoritmo Split Shapes layer randomly de SAGA, que ya hemos
utilizado en una lección anterior, pero hay una mejor manera de hacer eso, sin tener que crear ninguna
nueva capa intermedia que consiste en únicamente realizar una selección de features.
Para ello vamos a seleccionar solo los puntos que queremos usar para la interpolación (90%) y a
continuación ejecutaremos el algoritmo de interpolación.
 Para la selección vamos a utilizar el algoritmo Selección aleatoria o Random Selection de
QGIS. Ejecútalo con los siguientes parámetros:
De esta manera, se seleccionarán en pantalla el 90% de los puntos.

Ahora vamos a realizar varias interpolaciones utilizando diferentes métodos. La primera interpolación
con el algoritmo Inverse distance weighted interpolation de SAGA. Ejecuta dicho algoritmo con los
siguientes parámetros:
 En la casilla Attribute introduce el campo VALUE .
 En la casilla de Search Range elige [0] search radius (local) y en search Radius
elige 20000 .
 En el tamaño de la celda de salida (cellsize) es de 100 m y deja los demás parámetros por
defecto.
68
 Presiona Ejecutar y renombra la capa de salida en el proyecto de QGIS con el nombre IDW.
Para comprobar la calidad de la interpolación, ahora podemos utilizar los puntos que no están
seleccionados. En cada uno de esos puntos, conocemos la elevación real (el valor en la capa de
puntos) y la elevación interpolada (el valor en la capa ráster recién creada). Por tanto, Podemos
comparar los dos calculando las diferencias entre esos valores.
 Ya que vamos a utilizar los puntos que no sean seleccionados, primero, vamos a invertir la
selección. Abre la tabla de atributos de la capa points y presiona el botón de invertir la selección
. Ahora tendremos seleccionados solo el 10% de los puntos, puntos que no han intervenido
en la creación del ráster.
69
Ahora amos a añadir un nuevo campo a la capa points que contendrá el valor interpolado del punto
para más adelante poder restar el valor real del interpolado para realizar una estimación del error.
 Ejecuta el algoritmo Add raster values to points de SAGA.
Marca la casilla Objetos seleccionados solamente . En la casilla Grids selecciona la

capa IDW.
Este algoritmo creará una nueva capa de puntos (solo con los puntos seleccionados) que será copia
de la capa points.
Obtendremos una nueva capa Result con varias columnas, la columna VALUE con el valor original
del punto (el valor real) y el campo TARGET_OUT con el valor preveniente del ráster interpolado (el
valor estimado). Podremos comprar ambos valores para cuantificar la calidad de nuestra interpolación.
Para cuantificar esta comparación de los dos valores, vamos a calcular el error de en cada uno de los
puntos como la diferencia entre VALUE (valor verdadero) y TARGET_OUT (valor estimado).
70
 Ejecuta para ello el algoritmo Field Calculator o Calculadora de campos de QGIS. Este
algoritmo es igual que la típica calculadora de campos de QGIS pero como salida creará una
nueva capa, en lugar de actualizar la capa existente.
La tabla de atributos de la capa resultado será:
 Ahora vamos a calcular estadísticos sobre el campo error.
 Ejecuta el algoritmo de QGIS Basic statistics

for fields o Estadísticas básicas para
campos y elige el campo error .
Estos valores cambiarán, puesto que

previenen de una muestra aleatoria del 10%
de los puntos. En cualquier caso, te deben
salir del mismo orden de magnitud.
Nota
Podemos sacar importantes conclusiones como que la media de los errores es 0.66 m luego la
superficie estimada digamos que está un poco subestimada, ya que está como media 0.66 metros por
debajo de la superficie real.
Y la otra conclusión es la desviación típica que es de 11.5 m y nos da una idea clara del error de los
puntos estimados, ya que coincide prácticamente con el error medio cuadrático (RMS).
71
Se pide al alumno que repita el procedimiento para otros tipos de interpolaciones. Para ello, sigue en
orden los pasos que se detallan a continuación:
 Selecciona de nuevo la selección inversa de la capa points, para tener otra vez el 90% de
los puntos seleccionados.
 Ejecuta el algoritmo de interpolación Interpolate (Cubic spline) de SAGA: selecciona la capa

de entrada points y en la casilla de Attribute el valor VALUE . Renombra la capa a Cubic
Splines.
Para todos los métodos de interpolación, acuérdate de poner un tamaño de celda de 100m y
de marcar la opción de solo los objetos seleccionados .
 Ejecuta el algoritmo de interpolación Nearest Neighbour de SAGA: selecciona la capa de

entrada points y en la casilla de Attribute el valor VALUE y deja los demás parámetros por
defecto. Renombra la capa a Nearest.
 Ejecuta el algoritmo de interpolación Triangulation de SAGA: selecciona la capa de entrada

points y en la casilla de Attribute el valor VALUE y deja los demás parámetros por defecto.
Renombra la capa a Triangulation.
 Selecciona de nuevo la selección inversa de la capa points, para tener otra vez el 10% de
los puntos seleccionados para hacer el control.
 Repite tres veces el procedimiento de los algoritmos Add raster values to points y Field
Calculator para crear 3 capas con los valores estimados en cada punto y crea estadísticos
de las tres capas. Acuérdate de marcar la opción de solo en los objetos seleccionados.
 Rellena la siguiente tabla en la plantilla de resultados

IDW Cubic Splines Nearest Triangulation
Media error 0.66
Desviación típica 11.5
También es interesante tratar de interpolar la capa de puntos que contiene la columna error por
dicho campo, para visualizar de forma gráfica en qué partes de la superficie se comete más error. Por
ejemplo, la imagen inferior muestra los errores de la interpolación por Cubic Splines.
72
12.22 Ejecución iterativa de algoritmos

Resumen
Esta lección muestra una forma diferente de ejecutar algoritmos que usan capas vectoriales, al
ejecutarlos repetidamente, e iterar sobre las entidades de una capa vectorial de entrada.
Ya conocemos el modelador gráfico, que es una forma de automatizar tareas de procesamiento. Sin
embargo, en algunas situaciones, el modelador puede que no sea lo que necesitemos para automatizar
una tarea dada. Vamos a ver una de estas situaciones y cómo resolverlo fácilmente utilizando una
funcionalidad diferente: la ejecución iterativa de algoritmos.
 Carga el proyecto con los datos de la lección (proyecto iterative.qgs en processing >
example15 ). Debe tener un aspecto como este:
Reconocerás nuestro DEM utilizado en los los capítulos anteriores y las cuencas extraídas. Imagina
que necesitas cortar el DEM en varias capas más pequeñas, cada una de ellas contiene sólo los datos
de elevación correspondientes a una sola cuenca. Eso es útil si más adelante deseas calcular algunos
parámetros relacionados con cada cuenca, como su elevación media.
 Para recortar el DEM por una sólo una sola cuenca, primero hay que seleccionar la cuenca
deseada. Selecciona cualquier cuenca de la capa watersheds.
 Sólo el polígono seleccionado se utilizará para recortar la capa ráster. Ejecuta el algoritmo Clip
raster with polygon de SAGA con la opción de objetos seleccionados solamente
marcada:
Hacer esto para todas las cuencas producirá el resultado que estamos buscando, pero es demasiado
repetitivo. En su lugar, vamos a ver cómo automatizar esta rutina.
Primero elimina la selección anterior de la capa watersheds, por lo que todos los polígonos se utilicen
de nuevo.
73
 Ahora abre el algoritmo Clip raster with polygon y selecciona las mismas entradas que
antes, pero esta vez haz clic sobre el botón que se encuentra a la derecha de la capa
vectorial de entrada, donde se ha seleccionado la capa de cuencas.
El botón se quedará presionado.
 Ejecuta el algoritmo.
Este botón hará que la capa de entrada seleccionada sea dividida en tantas capas como features
contenga, cada una de esas capas contendrá un solo polígono. De esta forma, el algoritmo se ejecuta
una vez para cada una de esas capas. El resultado será varias capas ráster con los recortes.
Aquí está el resultado que se obtendrá si se ejecuta el algoritmo de recorte como se ha explicado.
Para cada capa, la paleta de color blanco y negro, (o cualquier paleta que esté utilizando), se ajusta de
manera diferente, desde valores un mínimo a sus valores máximos. Esa es la razón por el cual se
pueden ver las diferentes piezas y los colores no parecen coincidir en la frontera entre las capas. Los
valores, sin embargo, sí encajan.
Si introduce un nombre de archivo de salida, los archivos resultantes serán nombrados utilizando ese
nombre de archivo y un número correspondiente para cada iteración como sufijo.
74
12.23 Más ejecución iterativa de algoritmos

Resumen
Esta lección muestra cómo combinar la ejecución iterativa de algoritmos con el modelador de conseguir
una mayor automatización.
La ejecución iterativa de algoritmos está disponible no sólo para los algoritmos incorporados, sino
también para los nuevos algoritmos que se pueden crear con los modelos. Vamos a ver cómo combinar
un modelo y la ejecución iterativa de algoritmos, para obtener resultados más complejos con facilidad.
Los datos para este ejercicio son los mismos que el ejercicio anterior. En este caso, en lugar de recortar
el DEM con cada uno de los polígonos de las cuencas hidrográficas, añadiremos algunos pasos
adicionales para calcular el histograma de superficie para cada uno de ellos, para estudiar cómo la
elevación se distribuye dentro de la cuenca.
Ya que tenemos un flujo de trabajo que involucra varios pasos (recorte + cálculo de la curva de
hipsométrica), crear el modelo correspondiente para definir el flujo de trabajo.
Trata de crear un modelo como el que aparece en la imagen inferior. La capa recortada no es el
resultado final en este caso, ya que estamos interesados sólo en las curvas, por lo que este modelo no
se genera ninguna capa, pero sólo una tabla con los datos de la curva.
 Crea un nuevo modelo y ponle el nombre: Clipping And Histogram . Escribe como grupo de
algoritmos My Models como en los ejemplos anteriores.
El modelo debe tener este aspecto (deja todos los parámetros del algoritmo Histogram Surface
de SAGA con el valor por defecto, excepto el parámetro Grid y el parámetro del resultado de
salida: Histograma.
IMPORTANTE: Para la entrada WATERSHEDS deberás elegir el tipo de entrada Objetos

Vectoriales, porque si eliges la entrada Capa Vectorial, entonces no se podrá aplicar el
algoritmo de forma iterativa sobre las cuencas.
 Guárdalo también con el nombre clippingandhistogram y cierra el modelador.
Ahora vamos a ejecutar nuestro nuevo algoritmo pero de forma interactiva.

75
 Ejecuta el algoritmo Clipping And Histogram: Selecciona el DEM y la capa

watersheds , y no te olvides de cambiar el botón que indica que el algoritmo tiene que ser
ejecutado de forma iterativa.
El algoritmo se ejecutará varias veces, y se creará los histogramas de superficie correspondientes que
se añadirán al proyecto de QGIS.
 Realiza una de pantalla similar a la imagen inferior donde aparezca alguna de las tablas obtenida.
Pega la imagen en la plantilla de resultados
12.24 La interfaz de procesamiento por lote

Resumen
Esta lección presenta la interfaz de procesamiento por lote, que permite ejecutar un solo algoritmo con
un conjunto de diferentes valores de entrada.
Algunas veces un algoritmo dado tiene que ser ejecutado repetidamente con diferentes entradas. Esto
es, por ejemplo, el caso cuando un conjunto de archivos de entrada tienen que ser convertidos de un
formato a otro, o cuando varias capas en una proyección dada deben ser convertidas a otra.
76
En ese caso, llamando al algoritmo repetidamente en la caja de herramientas no es la mejor opción. En

lugar de ello, debemos utilizar la interfaz de procesamiento por lotes, que simplifica en gran medida el
rendimiento de una ejecución múltiple de un algoritmo dado. Para ejecutar un algoritmo como un
proceso por lotes, búsquela en la caja de herramientas, y en lugar de hacer doble clic sobre él, haz clic
derecho en él y selecciona Ejecutar como proceso por lotes
 Crea un nuevo proyecto en QGIS. Los datos a utilizar en esta lección están formados por un
conjunto de tres archivos shape (en processing > example16 ), pero no hay un proyecto
QGIS.
Esto es porque, cuando el algoritmo se ejecuta como un proceso por lote, la capa de entrada
se puede seleccionar ya sea desde el proyecto QGIS actual o desde los archivos. Eso hace
que sea más fácil procesar grandes cantidades de capas, como por ejemplo, todas las capas
en una carpeta determinada
 Ejecuta usando procedimiento por lotes el algoritmo de QGIS Reproyectar capa

(reproject layer), tras ejecutarlo usando procesamiento por lotes obtendrás el siguiente
diálogo:
Cada fila de la tabla del diálogo de proceso por lotes representa una sola ejecución del algoritmo. Las
celdas en una fila corresponden a parámetros necesarios por el algoritmo.
Definir el proceso por lotes consiste en rellenar la tabla con los valores correspondientes, y el diálogo
en sí contiene varias herramientas para hacer esta tarea más fácil.
Vamos a empezar llenando los campos de uno en uno. La primera columna para rellenar es la Capa
de entrada. En lugar de introducir los nombres de cada una de las capas que queremos procesar,
puede seleccionar todas ellos y dejar que el diálogo ponga uno en cada fila.
 Haz clic en el botón de la primera fila de la capa de entrada y selecciona la opción

Seleccionar archivos. En el cuadro de diálogo de selección de archivos emergente,
selecciona los tres archivos shp a reproyectar: pt1.shp, pt2.shp y pt3.shp del
directorio example16 . Los tres ficheros se distribuirán en tres filas de forma automática.
Si seleccionamos más capas, nuevas filas se añadirán automáticamente. Si desea llenar las entradas
manualmente, se puede añadir más más filas utilizando el botón de Añadir fila.
77
Vamos a convertir todas estas capas al SRC EPSG:23029 , así que tenemos que seleccionar ese SRC
en el segundo campo ( SRC objetivo ). Queremos lo mismo en todas las filas, pero no tenemos que
repetir el procedimiento para cada fila.
 Para ello, establece el SRC EPSG:23029 para la primera fila (la fila de la parte superior)
con el botón
 A continuación haz clic en Autorellenar y elige Rellenar hacia abajo . Eso hace que
todas las celdas de la columna se llenen con el valor de la celda superior.
Finamente, tenemos que seleccionar un archivo de salida para cada ejecución, que contendrá la capa
reproyectada correspondiente. Una vez más, vamos a hacerlo sólo para el primer registro.
 Haz clic en el botón de la primera fila, en el campo Reprojectada y busca la

carpeta donde se deseas colocar los archivos de salida. Escribe un nombre de archivo (por
ejemplo, reprojected.shp )
 Haz clic en Guardar/Aceptar en el diálogo de selección de archivo y entonces aparecerá un

cuadro de entrada como el siguiente:
Si selecciona la opción No rellenar automáticamente , se llenará solo la fila actual. Si se

selecciona alguna de las otras dos, todas las filas se llenarán con un patrón predeterminado.
 En este caso, selecciona la opción Rellenar con valores de parámetro , y el

parámetro a usar va a ser Capa de entrada en el menú desplegable más abajo. Eso hará
que el valor en la Capa de entrada (es decir, el nombre de la capa) se añada al nombre del
archivo que hemos añadido, por lo que cada nombre de archivo de salida será diferente.
La tabla de procesamiento por lotes ahora debería tener este aspecto:
 Por último, marca la opción Cargar capas al completar debajo de la tabla. De esta manear,
puedes ver los resultados cargados en QGIS automáticamente en este caso.
 Haz clic en Ejecutar y el proceso por lote será ejecutado. Si todo ha ocurrido bien, todas las
capas se han procesado y se han creado 3 nuevas capas.
78
 Puedes volver a la pestaña de Parámetros si deseas ver de nuevo la tabla de la ejecución

por lotes.
12.25 Modelos con procesamiento por lote

Resumen
Esta lección muestra otro ejemplo de la interfaz de procesamiento por lote, pero esta vez usando un
modelo en lugar de un algoritmo integrado
Los modelos se comportan igual que cualquier otro algoritmo, y por tanto se pueden utilizar en la interfaz
de procesamiento por lotes. Para demostrarlo, vamos a hacer uso de un modelo creado anteriormente
que era Watershed from DEM with threshold
 Crea un nuevo proyecto de QGIS
 Ejecuta este modelo pero con lotes. El diálogo de procesamiento por lotes de este algoritmo será:
 Selecciona el archivo DEM correspondiente a esta lección (p. ej.: fichero dem25.tif en
example12 ). Se creará una primera fila en la tabla con la capa de entrada de dem25.
Vamos a querer ejecutar tres veces el algoritmo, así que añade dos filas más a la tabla con el
botón
 Haz clic en Autorellenar y selecciona rellenar hacia abajo como has hecho antes.
 A continuación, introduce tres valores de umbral diferentes, p. ej.: 1000000, 100000 y 10000.
79
Faltaría configurar el parámetro de salida (columna watersheds).
 Para ello, elige un fichero shp ( watershed.shp ) en una carpeta y selecciona luego Rellenar
con números para añadir un número correlativo al final del nombre del fichero.
 Pulsa Ejecutar y obtendrás 3 nuevas capas correspondientes a los 3 valores especificados en el

umbral.
 Realiza una de pantalla similar a la imagen inferior. Pega la imagen en la plantilla de resultados
¡Enhorabuena, has concluido el módulo 9!
Por favor continúa con el curso y no olvides ir rellenando

la plantilla del documento de resultados. Esta plantilla la
subirás a final del curso a través de la plataforma
PoliFormat.
Ahora mismo es un buen momento para que calcules de forma aproximada las horas que has dedicado
de esfuerzo a la realización completa de este módulo (clases de teoría, clases de laboratorio, tiempo
dedicado en casa para finalizar las prácticas, etc.) y contestes al sondeo “Horas de dedicación del
módulo 9”.

Módulo 9 Curso de QGIS La Guía de Procesamiento de QGIS

Cargado por

Copyright:

Formatos disponibles

Módulo 9 Curso de QGIS La Guía de Procesamiento de QGIS

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Módulo 9 Curso de QGIS La Guía de Procesamiento de QGIS

Cargado por

Copyright:

Formatos disponibles

1

MÓDULO 9. La guía de procesamiento de QGIS

La guía de procesamiento de QGIS ............................................................................................... 3

La guía de procesamiento de QGIS

12.2 Caja de herramientas de procesado

12.3 Ejecutar nuestro primer algoritmo

 Abra el proyecto de QGIS correspondiente a esta lección situado en la carpeta (processing

 Seleccione polygons como capa como entrada.

Cuando ejecutes un algoritmo comprueba también en la tabla de atributos de la capa resultante, en

 Prueba tú mismo a guardarlo utilizando formatos de archivo diferentes (usa por

 Abre la tabla de atributos y comprueba los resultados:

12.4 Más algoritmos y tipos de datos

Campos X e Y: Campos de la tabla alfanumérica que contienen las coordenadas de los

 Ahora pulsa Ejecutar para obtener la capa.

 Seleccione rectángulo (polígono) en el tipo de cuadrícula.

 En Extensión de la cuadrícula, haz clic en el botón de la

 Como espaciado vertical y horizontal escribe 0,0001 .

 Presiona Ejecutar y obtendrás la capa de retícula.

Finalmente queremos una cuadrícula más o menos así,

12.4.1 Almacenamiento permanente en un directorio

 En lugar de ello, desde el menú Configuración ‣ Opciones, pestaña Procesos y en la

12.5 SRCs: Reproyectando

 Abre el algoritmo Agregar atributos de geometría (Add geometry attributes) :

 Selecciona como Capa de entrada la capa 4326.

 Abre el algoritmo de QGIS Reproyectar capa:

12.6.1 Realizar una selección utilizando la caja de

 Abre el algoritmo Selección aleatoria (random

 Deja los valores con la imagen inferior, se

12.7 Ejecución de algoritmos externos

Un proveedor de algoritmos de especial interés es SAGA (Sistema Automatizado de Análisis

 Elige un porcentaje de 50% y ejecuta el algoritmo.

La comprensión de este tipo de problemas le ayudará a resolverlos y encontrar una explicación a lo

12.8 El registro de procesamiento

Además también aparecen muchos mensajes de registro de Python, de la caja de procesos y de

12.8.1 Ejecutando un algoritmo desde código

 Abre el menú Complementos ‣ Consola de Python

 Después de presionar enter, se ejecutará el comando y se seleccionarán los 5 puntos de la capa

12.9 Calculadora ráster. Valores sin dato (no-data)

 Fíjate que puede haber varios algoritmos similares, en

El diálogo contiene varios parámetros:

Como puedes apreciar la visualización de la capa no es muy representativa debido a como se

Aquí está la capa que conseguirás:

 Selecciona la herramienta de identificar para

Aquí está la capa resultante:

12.9.1 Tipo del ráster de salida

Tipo Valor mínimo Valor máximo Bits/Bytes por píxel

Capa Tamaño en KB Tipo de datos (información de Valor utilizado para representar el

 Rellena dicha tabla en la plantilla de resultados

12.9.2 ¿Qué calculadora ráster utilizar?

GDAL SAGA QGIS

12.10 Calculadora de campos

("WHITE" / "SHAPE_AREA") * 1000000

 Rellena el diálogo de parámetros como la imagen siguiente y presiona Aceptar.

12.11 Definición de extensiones

 Abre el proyecto de QGIS extent situado en processing / example6 .

- Usar la extensión del lienzo: al seleccionarlo usará la extensión actual de la vista/lienzo de

 Selecciona como extensión de salida la misma que la capa watersheds.

12.12 Salida en HTML