La consola permite a los usuarios avanzados incrementar su productividad y realizar operaciones complejas que no se pueden realizar utilizando cualquiera de los otros elementos de la GUI del marco de procesamiento. Modelos que involucran varios algoritmos se pueden definir mediante la interfaz de línea de comandos y operaciones adicionales tales como bucles y sentencias condicionales que se pueden añadir para crear flujos de trabajo más flexibles y potentes.
No hay una consola de procesos en QGIS, pero todos los comandos de procesamiento están disponibles desde la consola de Python integrada en QGIS. Eso significa que se pueden incorporar esos comandos en a consola de trabajo y conectar algoritmos de procesos para todos los otros objetos espaciales (incluyendo los métodos del API de QGIS) disponibles a partir de allí
El código se puede ejecutar desde la consola de Python, incluso si no especifica ningún método de procesamiento, se puede convertir en un nuevo algoritmo que más tarde puede llamar desde la caja de herramientas, el modelador gráfico o algún otro componente, tal como lo hace con cualquier otro algoritmo. De hecho, algunos de los algoritmos que se pueden encontrar en la caja de herramientas son sencillas secuencias de comandos.
En esta sección, veremos como utilizar algoritmos de procesado desde la consola de Python de QGIS, y también cómo escribir algoritmos utilizando Python.
Lo primero que tiene que hacer es importar las funciones de procesamiento con la siguiente línea:
>>> import processing
Now, there is basically just one (interesting) thing you can do with that from the console: execute an algorithm. That is done using the runalg() method, which takes the name of the algorithm to execute as its first parameter, and then a variable number of additional parameters depending on the requirements of the algorithm. So the first thing you need to know is the name of the algorithm to execute. That is not the name you see in the toolbox, but rather a unique command–line name. To find the right name for your algorithm, you can use the alglist() method. Type the following line in your console:
>>> processing.alglist()
Veras algo como esto:
Accumulated Cost (Anisotropic)---------------->saga:accumulatedcost(anisotropic)
Accumulated Cost (Isotropic)------------------>saga:accumulatedcost(isotropic)
Add Coordinates to points--------------------->saga:addcoordinatestopoints
Add Grid Values to Points--------------------->saga:addgridvaluestopoints
Add Grid Values to Shapes--------------------->saga:addgridvaluestoshapes
Add Polygon Attributes to Points-------------->saga:addpolygonattributestopoints
Aggregate------------------------------------->saga:aggregate
Aggregate Point Observations------------------>saga:aggregatepointobservations
Aggregation Index----------------------------->saga:aggregationindex
Analytical Hierarchy Process------------------>saga:analyticalhierarchyprocess
Analytical Hillshading------------------------>saga:analyticalhillshading
Average With Mask 1--------------------------->saga:averagewithmask1
Average With Mask 2--------------------------->saga:averagewithmask2
Average With Thereshold 1--------------------->saga:averagewiththereshold1
Average With Thereshold 2--------------------->saga:averagewiththereshold2
Average With Thereshold 3--------------------->saga:averagewiththereshold3
B-Spline Approximation------------------------>saga:b-splineapproximation
...
Esa es una lista de todos los algoritmos disponibles, ordenada alfabéticamente, junto con sus nombres de linea de comandos correspondientes.
Puede utilizar una cadena como parámetro para este método. En lugar de devolver la lista completa de algoritmos, que sólo mostrará aquellos que incluyen esa cadena. Si, por ejemplo, se busca un algoritmo para calcular la pendiente de un DEM, el tipo``alglist(“slope”)`` obtendrá el siguiente resultado:
DTM Filter (slope-based)---------------------->saga:dtmfilter(slope-based)
Downslope Distance Gradient------------------->saga:downslopedistancegradient
Relative Heights and Slope Positions---------->saga:relativeheightsandslopepositions
Slope Length---------------------------------->saga:slopelength
Slope, Aspect, Curvature---------------------->saga:slopeaspectcurvature
Upslope Area---------------------------------->saga:upslopearea
Vegetation Index[slope based]----------------->saga:vegetationindex[slopebased]
El resultado podría cambiar dependiendo de los algoritmos que se tienen disponibles.
Ahora es más fácil encontrar el algoritmo que se busca y el nombre de línea de comando, en este caso saga:slopeaspectcurvature.
Una vez que se conoce el nombre de línea de comandos del algoritmo, el siguiente paso es determinar la sintaxis correcta para ejecutarlo. Eso significa saber que parámetros se necesitan y el orden en el que tienen para pasarlos cuando se llame al método runalg(). Hay un método para describir un algoritmo a detalle, que se puede utilizar para obtener una lista de los parámetros que requiere un algoritmo y las salidas que va a generar. Para obtener esta información, se puede utilizar el método alghelp (name_of_the_algorithm). Utilice el nombre de línea de comandos del algoritmo, no el nombre descriptivo completo.
Llamar al método con saga:slopeaspectcurvature como parámetro, se obtiene la siguiente descripción:
>>> processing.alghelp("saga:slopeaspectcurvature")
ALGORITHM: Slope, Aspect, Curvature
ELEVATION <ParameterRaster>
METHOD <ParameterSelection>
SLOPE <OutputRaster>
ASPECT <OutputRaster>
CURV <OutputRaster>
HCURV <OutputRaster>
VCURV <OutputRaster>
Ahora se tiene todo lo necesario para ejecutar cualquier algoritmo. Como ya hemos mencionado, sólo hay un solo comando para ejecutar algoritmos: runalg(). Su sintaxis es la siguiente:
>>> processing.runalg(name_of_the_algorithm, param1, param2, ..., paramN,
Output1, Output2, ..., OutputN)
La lista de parámetros y salidas para añadir dependen del algoritmo que se desean ejecutar, y es exactamente la lista que el método alghelp() le da, en el mismo orden que se muestra.
Dependiendo del tipo de parámetro, los valores se introducen de manera diferente. La siguiente lista da una rápida revisión de cómo introducir los valores para cada tipo de parámetro de entrada.
La capa ráster, vectorial o tabla. Sólo tiene que utilizar una cadena con el nombre que identifique los datos del objeto a utilizar (el nombre que tiene en la tabla QGIS de contenido) o un nombre de archivo (Si no abre la capa correspondiente, se abrirá pero no se añadirá al lienzo del mapa). Si tiene una instancia de un objeto de QGIS que represente la capa, también puede pasarlo como parámetro. Si la entrada es opcional y no quiere utilizar cualquier objeto de dato, utilice None.
Selección. Si un algoritmo tiene un parámetro de selección, el valor de ese parámetro debe ser introducido mediante un valor entero. Para conocer las opciones disponibles, se puede utilizar el comando algoptions(), como se muestra en el siguiente ejemplo
>>> processing.algoptions("saga:slopeaspectcurvature")
METHOD(Method)
0 - [0] Maximum Slope (Travis et al. 1975)
1 - [1] Maximum Triangle Slope (Tarboton 1997)
2 - [2] Least Squares Fitted Plane (Horn 1981, Costa-Cabral & Burgess 1996)
3 - [3] Fit 2.Degree Polynom (Bauer, Rohdenburg, Bork 1985)
4 - [4] Fit 2.Degree Polynom (Heerdegen & Beran 1982)
5 - [5] Fit 2.Degree Polynom (Zevenbergen & Thorne 1987)
6 - [6] Fit 3.Degree Polynom (Haralick 1983)
En este caso, el algoritmo tiene uno de tales parámetros, con siete opciones. Tenga en cuenta que ordenar en base cero.
La entrada múltiple. El valor es una cadena con descriptores de entrada separadas por punto y coma (;). Como en el caso de capas individuales o tablas, cada descriptor de entrada se puede el nombre del objeto de datos, o su ruta de archivo.
El campo de la tabla de XXX. Utilice una cadena con el nombre del campo a usar. Este parámetro es sensible a mayúsculas y minúsculas.
Tabla fija. Escribir la lista de todas las tablas de valores separadas por comas (,) y cerrar entre comillas ("). Los valores que empiezan en la fila superior y van de izquierda a derecha. También se puede utilizar un arreglo 2-D de valores que representen la tabla.
SRC. Introduzca el número del código EPSG del SRC deseado.
Extensión. Se debe utilizar una cadena con valores de xmin, xmax, ymin y ymax` separados por comas (,``).
Los parámetros boolean, archivo, cadena y numéricos no necesitan alguna explicación adicional.
Los parámetros de entrada tales como valores string, booleanos o numericos tienen valores predeterminados. Para utilizarlos, especificar None en la entrada del parámetro correspondiente.
Para objetos de datos de salida, escriba la ruta del archivo que se utilizará para guardarlo, del mismo modo que se hace desde la caja de herramientas. Si desea guardar el resultado a un archivo temporal, use None. La extensión del archivo determina el formato de archivo. Si se ingresa la extensión no reconocida por el algoritmo, el formato de archivo predeterminado par el tipo de salida se utilizará, y su extensión correspondiente anexa a la ruta del archivo dado.
A diferencia de cuando un algoritmo se ejecuta desde la caja de herramientas, las salidas no se añaden a la vista del mapa si se ejecuta el mismo algoritmo desde la consola de Python. Si desea añadir una salida a la vista del mapa, tiene que hacerlo por si mismo después de ejecutar el algoritmo. Para ello, puede utilizar los comandos de la API QGIS, o, aún más fácil, utilice uno de los métodos prácticos previstos para tales tareas.
El método runalg regresa un diccionario con los nombres de salida (los que se muestran en la descripción del algoritmo) como llaves y la ruta del archivo de esas salidas como valores. Se pueden cargar esas capas al pasar las rutas de archivo correspondientes al método load().
Además de las funciones que se utilizan para llamar algoritmos, que importan el paquete procesos también importará algunas funciones adicionales que hacen que sea más fácil trabajar con datos, particularmente datos vectoriales. Ellos son sólo funciones de confort que envuelven algunas funciones del API de QGIS, por lo general con una sintaxis menos compleja. Estas funciones se deben utilizar en el desarrollo de nuevos algoritmos, ya que hacen que sea más fácil de operar con datos de entrada.
Below is a list of some of these commands. More information can be found in the classes under the processing/tools package, and also in the example scripts provided with QGIS.
getObject(obj): Regresa un objeto QGIS (una capa o tabla) del objeto pasado, que puede ser un nombre de archivo o el nombre de un objeto en la lista de capas de QGIS.
values(layer, fields): Regresa los valores en la tabla de atributos de una capa vectorial, para los campos pasados. Los campos se pueden pasar como nombres de campos o como indices de archivos de base cero. Devuelve un diccionario de listas, con el identificador del campo pasado como llaves. Se considera la selección existente.
features(layer): Devuelve un iterador sobre las características de una capa vectorial, considerando la selección existente.
uniqueValues(layer, field): Devuelve una lista de valores únicos para un atributo dado. Los atributos se pueden pasar como un nombre de campo o indice de campo de base cero. Se considera la selección existente.
Puede crear sus propios algoritmos escribiendo código Python y añadiendo unas pocas líneas extras para suministrar información adicional necesaria para definir la semántica del algoritmo. Se puede encontrar en el menú guilabel:Crear nuevo script bajo el grupo Herramientas en el bloque de algoritmos Script de la caja de herramientas. Haga doble clic en él para abrir el diálogo de edición de script. Eso es donde debe escribir su código. Guarde el script en la carpeta scripts (la carpeta predeterminada cuando abre el diálogo del archivo guardado) con la extensión .py automáticamente crea el algoritmo correspondiente.
El nombre del algoritmo (el que podrá ver en la caja de herramientas) se crea a partir del nombre de archivo, la eliminación su extensión y la sustitución de guiones bajos con espacios en blanco.
Vamos a echar un vistazo a el siguiente código, que calcula el Índice de Humedad topográfica (TWI) directamente de un DEM.
##dem=raster
##twi=output
ret_slope = processing.runalg("saga:slopeaspectcurvature", dem, 0, None,
None, None, None, None)
ret_area = processing.runalg("saga:catchmentarea(mass-fluxmethod)", dem,
0, False, False, False, False, None, None, None, None, None)
processing.runalg("saga:topographicwetnessindex(twi), ret_slope['SLOPE'],
ret_area['AREA'], None, 1, 0, twi)
Como puede ver, el calculo implica tres algoritmos, todos ellos provenientes de SAGA. El último que calcula el TWI, pero se necesita una capa de pendientes y una capa de acumulación de flujo. No tenemos estas capas, pero ya tenemos el DEM, podemos calcularlas llamando a los algoritmos SAGA correspondientes.
La parte del código donde este procesamiento se lleva a cabo no es difícil de entender si ha leído las secciones anteriores de este capítulo. Las primeras líneas, sin embargo, necesitan alguna explicación adicional. Proporcionan la información que se necesita para convertir su código en un algoritmo que se puede ejecutar desde cualquiera de los componentes GUI, como la caja de herramientas o el modelador gráfico.
Estas líneas comienzan con un doble símbolo de comentario en Python (##) y tiene la siguiente estructura:
[parameter_name]=[parameter_type] [optional_values]
Aquí esta una lista de todos los tipos de parámetros que se admiten en scripts de procesamiento, su sintaxis y algunos ejemplos.
ráster. Una capa ráster.
vector. Una capa vectorial.
table. Una tabla.
número. Un valor numérico. Un valor por defecto debe ser proporcionado. Por ejemplo, depth=number 2.4.
string. Una cadena de texto. Como en el caso de valores numéricos, por defecto se debe añadir un valor. Por ejemplo, name=string Victor.
boolean. Un valor boolean. Añade True o False después para establecer el valor predeterminado. Por ejemplo, verbose=boolean True.
ráster múltiple. Un conjunto de capas ráster de entrada.
Vector múltiple. Un conjunto de capas vectoriales de entrada.
Campo. Un campo es la tabla de atributos de una capa vectorial. El nombre de la capa se tiene que añadir después de la etiqueta Campo. Por ejemplo, si ha declarado una vectorial de entrada con mylayer=vector, podría utilizar myfield=field mylayer para añadir un campo de esa capa como parámetro.
folder. Una carpeta.
file. A nombre de archivo.
El nombre del parámetro es el nombre que se mostrará al usuario cuando ejecuta el algoritmo, y también el nombre de variable a utilizar en la secuencia de código. El valor introducido por el usuario para ese parámetro se asignará a la variable con ese nombre.
Cuando muestra el nombre del parámetro al usuario, el nombre será editado para mejorar su apariencia, en sustitución de guiones bajos con espacios. Así, por ejemplo, si desea que el usuario vea un parámetro llamado Un valor numérico, puede utilizar el nombre de la variable A_numerical_value.
Los valores de capas y tablas son cadenas que contienen la ruta del archivo del objeto correspondiente. Para convertirlos en un objeto QGIS, puede utilizar la función processing.getObjectFromUri(). Las múltiples entradas también tienen un valor de cadena, que contiene las rutas de los archivos a todos los objetos seleccionados, separados por punto y coma (;).
Las salidas están definidas en una manera similar, utilizando los siguientes etiquetas:
ráster de salida
vector de salida
tabla de salida
html de salida
archivo de salida
número de salida
texto de salida
El valor asignado a las variables de salida es siempre una cadena con una ruta de archivo. Corresponderá a una ruta de archivo temporal en caso de que el usuario no haya introducido ningún nombre de archivo de salida.
Cuando declare una salida, el algoritmo intentará agregarlo a QGIS una vez que este terminado. Esa es la razón, por la cual el método runalg() no carga las capas que produce, la capa final TWI será cargada (utilizando el caso de nuestro ejemplo anterior), ya que se guarda en el archivo introducido por el usuario, que es el valor de la salida correspondiente.
No utilice el método load() en sus algoritmos de script, sino sólo cuando se trabaja con la línea de la consola. Si una capa es creada como salida de un algoritmo, debe ser declarada como tal. De lo contrario, usted no será capaz de utilizar correctamente el algoritmo en el modelador, ya que su sintaxis (según la definición de las etiquetas explicadas anteriormente) no coincidirá con lo que crea realmente el algoritmo.
Salidas ocultas (números y cadenas) no tienen un valor. En cambio, tiene que asignar un valor a los mismos. Para ello, basta con establecer el valor de una variable con el nombre que utilizó para declarar la salida. Por ejemplo, si ha utilizado esta declaración,
##average=output number
La siguiente linea establecerá el valor de salida a 5:
average = 5
Además de las etiquetas para los parámetros y resultados, también puede definir el grupo en las que se muestra el algoritmo, utilizando la etiqueta grupo.
Si su algoritmo toma mucho tiempo para procesar, es una buen idea informar al usuario. Se tiene una global llamada progreso disponible, con dos métodos posibles: setText(text) y setPercentage(percent) para modificar el texto y la barra de progreso.
Varios ejemplos son proporcionados. Por favor, consulte con ellos para ver ejemplos reales de cómo crear algoritmos utilizando las clases del marco de procesamiento. Haga clic derecho en cualquier script y seleccione Editar script para editar su código o sólo para verlo.
Al igual que en el caso de los modelos, puede crear documentación adicional para sus scripts, para explicar qué hacen y como utilizarlos. En el diálogo de edición de scripts, encontrará un botón [Editor de ayuda]. Haga clic en él y le llevará al diálogo de editor de ayuda. Compruebe la sección acerca del modelador gráfico para conocer más sobre este diálogo y cómo utilizarlo.
Los archivos de ayuda se guardan en el mismo folder como el script mismo, añadiendo la extensión .help al nombre del archivo. Tenga en cuenta que puede editar la ayuda de su script antes de guardarlo la primera vez. Si después cierra el diálogo de edición de script sin guardarlo (es decir, descartarlo), el contenido de la ayuda que escribió se perderá. Si su script ya fue guardado y tiene asociado un nombre de archivo, se guardara automáticamente.
Los scripts también pueden ser utilizados para establecer ganchos pre- y post ejecuciones, que se ejecutan antes y después de la ejecución de un algoritmo. Esto se puede utilizar para automatizar tareas que deben realizarse cada vez que se ejecuta un algoritmo.
La sintaxis es idéntica a la que se ha explicado anteriormente, pero una variable global adicional llamada alg está disponible, lo que representa el algoritmo que acaba de ser (o está a punto de ser) ejecutado.
En el grupo General del cuadro de diálogo de configuración de procesamiento se encuentran dos entradas llamadas Script preejecución y el :guilabel: Script postejecución donde el nombre de archivo de los scripts a ser ejecutados en cada caso se pueden introducir.